Neton 1.0.0: the Kotlin/Native server era starts here
Neton 1.0 is now in public beta. Kotlin/Native finally has an engineering-grade server application framework of its own.
Neton is a complete engineering framework ecosystem for Kotlin/Native. On top of native executables, it provides an application container, lifecycle, controllers, compile-time wiring, database transactions, security, cache, Redis, jobs, storage, structured logging, domain events, and AI integration as one foundation for large server applications.
This is a real framework built to carry complex business systems for the long term. Developers no longer have to choose between mature application engineering with a heavier runtime and native efficiency that requires assembling the entire foundation themselves.
Neton is built to deliver both: the engineering productivity of a mature framework and the startup, resource density, and deployment model of a Kotlin/Native executable.
Neton 1.0 is more than a version number. It marks Kotlin/Native's move from client-side sharing and systems work into the era of large, maintainable server applications.
This page tracks the Neton 1.0.0 line as a whole. 1.0.0 is in public beta today; the final release date is not yet fixed. For the exact artifact version to depend on, see Maven Central.
What Neton is
Neton is a next-generation web application framework for Kotlin/Native. It keeps the most valuable capabilities of established enterprise frameworks — declarative development, clear layers, a managed lifecycle, and integrated infrastructure — while replacing the implementation model based on runtime classpath scanning, reflection, and dynamic proxies.
KSP generates routes, parameter binding, entity tables, module wiring, and selected cross-cutting behavior at compile time. At runtime, the application executes code whose structure is already known rather than discovering its own architecture during startup.
The result is a native executable with no JVM dependency. Neton's sample applications have measured around 3 ms startup and roughly 12–20 MB resident memory in specific release builds; actual results depend on application code, dependencies, hardware, and I/O. The important change is broader than one benchmark: Kotlin becomes a practical option for dense containers, rapid scaling, edge nodes, and command-style services.
What it can build today
The Neton 1.0 public beta covers much more than HTTP:
- Web and APIs: annotated controllers, a routing DSL, parameter binding, middleware, and unified exception and response handling.
- Application lifecycle: deterministic startup, context freezing, fail-fast errors, and reverse resource shutdown.
- Database access: PostgreSQL, MySQL, and SQLite, a typed query DSL, coroutine-aware transactions, and generated-id handling.
- Security: Authenticator + Guard, JWT, route-group authorization, permission annotations, and a frozen request identity.
- Cache and Redis: L1/L2 cache, rate limiting, distributed locks, and explicit configuration precedence.
- Infrastructure: structured logging, traceId/spanId propagation, scheduled jobs, validation, and local or S3-compatible storage.
- Domain collaboration: in-process domain events and a retryable event contract whose persistent transport remains an application choice.
- AI integration: an optional
neton-aimodule that does not burden the base runtime. - Replaceable HTTP transport: Ktor is the default adapter; applications can explicitly add the external Hyper4k adapter.
That makes Neton suitable for business APIs, BFFs, microservices, admin backends, payment and member systems, internal platforms, and Serverless or edge workloads where cold start and memory density matter.
What it is trying to disrupt
Neton resets the baseline for Kotlin backend engineering: a complete application framework, compile-time certainty, and Native runtime efficiency can exist together. That breaks three trade-offs teams have long been expected to accept.
Native efficiency should not require assembling everything yourself
Native server development often pushes directory structure, lifecycle, dependency wiring, database boundaries, logging, and error semantics into every application team. The binary stays small, but the engineering cost moves into each project.
Neton turns those recurring decisions into framework contracts. Native becomes a reusable engineering model, not only a deployment optimization.
An application framework should not require a heavy runtime
Declarative controllers, automatic wiring, and data mapping do not have to depend on runtime reflection. Neton moves that work into KSP: the API remains approachable while more mistakes become build-time failures.
It challenges the assumption that higher developer productivity must imply a heavier runtime.
Low resource usage should not require leaving Kotlin
Teams keep Kotlin's type system, coroutines, DSLs, and Multiplatform tooling while changing the runtime shape to a native executable. Neton offers a gradual path instead of requiring an immediate rewrite in another language.
Architecture for long-lived applications
Neton recommends and demonstrates one clear responsibility chain:
Controller -> Logic -> Table -> Model
HTTP domain data entityControllers own protocol and authorization. Logic owns business state and transaction orchestration. Tables own single-table persistence. Models remain plain data. These boundaries keep responsibilities obvious when an application grows to dozens of modules.
Neton also follows a stricter rule: a declared capability must work on the live runtime path. Invalid critical configuration fails at startup, and contracts cover routing, rate limiting, cache, security, transactions, logging, and lifecycle behavior. A long feature list matters less than the absence of silent, non-functional features.
Start in five minutes
Run the official starter:
git clone https://github.com/netonframework/neton-app.git
cd neton-app
./gradlew runOr add the current maintenance release to a Kotlin Multiplatform project:
implementation("com.netonstream:neton:1.0.0-beta2")The neton coordinate supplies core, logging, HTTP, and routing, while its BOM aligns optional modules:
implementation("com.netonstream:neton-database")
implementation("com.netonstream:neton-security")
implementation("com.netonstream:neton-redis")
implementation("com.netonstream:neton-cache")What beta means
The 1.0.0 beta means the architecture and core contracts are established and exercised by a real multi-module application. It does not mean that every API is permanently frozen. Before 1.0.0 final, clarity, consistency, and long-term maintainability still take priority over compatibility with a weak design.
Neton supports macOS ARM64, Linux x64, Linux ARM64, and Windows x64. Every module except neton-database also supports macOS x64; its upstream database driver does not publish that target.
We want feedback from real systems, not only Hello World: authentication, permissions, transactions, cache, jobs, files, payments, and operational workflows. The best beta feedback is the kind that only appears after an application starts to grow.
A new option for Kotlin backends
The Neton 1.0 public beta moves Kotlin/Native servers from "capable of serving HTTP" to "capable of sustaining a large application." Kotlin/Native is no longer only an experimental server option; it now has a complete framework, a standard engineering structure, and validation in real business systems.
It establishes a complete new option for the next generation of Kotlin servers:
Why should a Kotlin backend have to choose between mature engineering productivity and native efficiency?
Neton's answer is that it should not. The Kotlin/Native server era starts now.