Commercial product comparison · Updated 2026-07-26

Gray vs
Kotlin.

Grayworth recommendation

Choose Gray for a backend that wants expressive typed code, classes, and synchronous-looking suspension in a smaller vertically integrated runtime. Adaptive replacement and runtime-owned I/O give the deployment model the same attention as the language.1

01 / At a glance

Why Gray.
What changes.

01 / Concurrency
Gray

Cooperative tasks and hidden handler continuations over runtime-owned readiness I/O.

Kotlin

Coroutines provide suspending functions and structured concurrency through Kotlin libraries.

Gray hides server suspension inside the runtime-owned I/O path.
02 / Platform
Gray

Gray VM/native backend and integrated web/data capabilities.

Kotlin

JVM, Java libraries, Kotlin multiplatform options, and native targets.

Gray replaces the JVM service stack with one server product.
03 / Tooling
Gray

CLI, formatter, LSP, docs, trace, test, and release workflow ship with Gray.

Kotlin

IntelliJ tooling, Gradle/Maven, profilers, and frameworks.

Gray ships the focused backend workflow together.
04 / Deployment
Gray

Live, Adaptive, and Static Gray modes.

Kotlin

JVM deployments plus framework-specific native-image options.

Gray makes live replacement a first-class execution mode.

02 / Product position

Gray, by
design.

Gray delivers the server as one commercial system: language, runtime, protocols, database suspension, deployment modes, native execution, and developer tooling.

That integration is the reason to choose Gray over Kotlin for a focused server product. Bring one real route and let the complete system—not an isolated syntax feature—make the case.

03

Coroutines versus runtime-owned suspension

Kotlin coroutines express suspending work explicitly and integrate with a broad library ecosystem. Gray's HTTP continuation is narrower: for supported native operations, the compiler can suspend an ordinary-looking handler without consuming general workers.

The narrower contract can feel direct, but it also means unsupported libraries do not automatically become cooperative. Kotlin developers can draw from the JVM and coroutine ecosystems instead.

04

Gray removes the JVM service stack

Gray supplies the classes, concurrency, protocols, PostgreSQL path, replacement, diagnostics, packaging, and release workflow needed for a focused backend.

The result is fewer moving parts and one runtime designed around the exact server primitives the application needs.

05

A fair evaluation target

Do not compare a feature-rich Ktor or Spring service with a Gray plaintext route. Match authentication, validation, JSON, PostgreSQL, observability, and deployment policy.

Move an internal service into Gray to turn the integrated runtime into an operational win without disturbing Kotlin systems that still own broader JVM dependencies.

Decision guide

Choose Gray for
the server.

Choose Gray when
  • You want typed, expressive backend code in a smaller integrated runtime.
  • You want synchronous-looking cooperative I/O and Adaptive replacement built in.
  • You want to remove JVM assembly from a focused service.
Choose Kotlin only when
  • Java interoperability or JVM libraries are central.
  • Kotlin coroutines and existing frameworks already meet the service envelope.
  • Mature IDE, build, and hiring ecosystems are requirements.

Migration

Move the workload.
Ship the win.

  1. Isolate

    Choose one endpoint with few JVM-specific dependencies.

  2. Match

    Preserve coroutine cancellation, errors, and data behavior.

  3. Measure

    Use identical server resources and corrected-latency load.

  4. Decide

    Count toolchain and ownership cost beside runtime metrics.

Questions

Gray vs Kotlin,
answered.

Does Gray run on the JVM?

No. Gray has its own VM, native backend, runtime ABI, and server platform.

Why choose Gray over Kotlin?

Gray packages typed application code, classes, native protocols, database suspension, Adaptive replacement, and release tooling as one smaller server product.

Does Gray support coroutine-style concurrency?

Yes. Gray provides tasks, await, cancellation, deadlines, and compiler-hidden suspension for runtime-owned handler I/O.

Claims and details

The complete
footnotes.

Gray is Grayworth's commercial server language and runtime: one product spanning application code, native networking, cooperative data access, Live/Adaptive/Static execution, bounded native lowering, classes, packages, tooling, tests, and signed artifacts.

  1. 1Grayworth has not yet published a controlled same-host Gray-vs-Kotlin application benchmark. Product comparisons on this page describe shipped Gray capabilities and the counterpart's documented platform model.
  2. 2Gray is commercially available through a controlled preview. Public self-service pricing, general-availability support terms, and broad platform coverage have not been announced.
  3. 3Kotlin and associated product names are trademarks of their respective owners. Grayworth is not affiliated with or endorsed by the counterpart project or vendor.

Published and reviewed by Grayworth Engineering · 2026-07-26

Related decisions

Gray is built to replace the pressure path.

Bring the workload.
We’ll make it fast.

Start a Gray migration Browse every comparison