Commercial product comparison · Updated 2026-07-26
Grayworth recommendation
Choose Gray for a new high-throughput API when direct synchronous-looking handlers, Adaptive replacement, integrated PostgreSQL, and measured pressure behavior belong in one product. Gray qualified at twice Go's highest tested request rate for both published routes in Grayworth's same-host qualification.1
01 / At a glance
Cooperative suspension keeps ordinary-looking handlers off the reactor while I/O is pending.
Goroutines and channels expose general-purpose concurrent execution.
Live, Adaptive replacement, bytecode fallback, and x86-64 native lowering.
Native compilation with a garbage-collected runtime.
HTTP/1.1, HTTP/2, WebSocket, TLS, PostgreSQL, JSON, static delivery, and sessions are runtime capabilities.
Usually assembled from the standard library and third-party packages.
Commercial preview with one accountable runtime and product owner.
Large production ecosystem and long compatibility history.
02 / Under pressure
Gray's highest qualifying tested rate was 60k requests/s for both plaintext and JSON. Go's was 30k requests/s for both routes under the same threshold.
| Fixture | Gray | Go |
|---|---|---|
| Plaintext | 60k/s · p99 85.76 ms | 30k/s · p99 5.68 ms |
| JSON | 60k/s · p99 81.15 ms | 30k/s · p99 5.38 ms |
| 45k plaintext | 99.5% delivery · p99 3.81 ms | 89.7% delivery · did not qualify |
| 45k JSON | 99.5% delivery · p99 5.90 ms | 92.3% delivery · did not qualify |
1 Same-host qualification. Full environment, threshold, and scope appear in Claims & details below.
Go exposes concurrency directly through goroutines and channels. Its runtime multiplexes goroutines across operating-system threads, and its standard tooling makes cross-platform native deployment routine.
Gray's server model starts from a different product goal: let a handler read synchronously while compiler-hidden continuations suspend database work through readiness-driven I/O. Adaptive mode can compile a replacement, publish it only after readiness, and drain the old worker without handing application code a reload protocol.
Gray reached twice Go's highest qualifying tested rate on both published server routes. It held the declared delivery and corrected-latency target at 60k/s; Go's final qualifying point was 30k/s.
At 30k/s Gray also posted the lower corrected p99: 2.73 ms versus 5.68 ms on plaintext and 3.09 ms versus 5.38 ms on JSON. At 45k/s Gray still delivered 99.5% of requested load while the Go fixture fell below the qualification threshold.
Move the Go routes where throughput, tail latency, database waits, or deployment friction have a real cost. Gray packages the language, runtime, data path, replacement model, and tooling together, so the port removes infrastructure as well as code.
JSON APIs, internal services, and latency-sensitive PostgreSQL routes are immediate targets. Run the Gray service beside Go during cutover, replay production-shaped traffic, then shift traffic when Gray meets the contract.
The published result is a same-host qualification for the declared minimal Go and Gray fixtures. It measures the requested-rate points, exact responses, delivery ratio, and corrected p99 in that environment; it does not rank every framework, deployment topology, payload, or production application built with Go.
Treat the evidence as a decision input, then reproduce the relevant contract with your own payloads, dependencies, concurrency, failure behavior, and operating limits before committing to a migration.
Gray centralizes the server path under one commercial runtime. Go may instead bring established ecosystem assets, platform reach, libraries, hiring depth, or operating practices that are material to the service.
The practical comparison includes observability, incident response, deployment, support boundaries, dependency ownership, and the cost of maintaining an additional runtime, not only handler throughput.
Start at a stable Go service boundary with an exact HTTP, data, and failure contract. Port one route or worker to Gray, keep the existing implementation live, and make rollback a tested operation.
Qualify behavior before volume: response bytes, authentication, validation, cancellation, timeouts, transactions, traces, dashboards, and on-call ownership should all be explicit before traffic moves.
Choose Gray when the route is pressure-sensitive and the value of an integrated language, runtime, networking, data path, replacement model, and tooling outweighs the cost of a focused port.
Keep Go when its ecosystem, compatibility commitments, operational model, or already-sufficient service envelope is the more valuable constraint. A credible decision names the workload, acceptance thresholds, owner, and rollback condition.
Decision guide
Migration
A Go http.Handler becomes a typed Gray handler with direct request and response primitives.
A normal-looking Gray database call is suspended by the compiler/runtime continuation path.
A Gray Static artifact packages bytecode and eligible native code with a versioned runtime ABI.
Run Gray beside Go, replay the same traffic, then move the route when Gray meets the production contract.
Questions
On Grayworth's published plaintext and JSON server tests, yes. Gray qualified at 60k/s on both routes; Go qualified at 30k/s.¹
Yes for Gray server applications. Cooperative tasks and compiler-hidden continuations keep concurrent I/O readable without requiring goroutine-style application architecture.
Move the routes where Gray's speed, integrated data path, or Adaptive deployment produces a real win. Run both during cutover, then retire the Go route after Gray owns the production contract.
It proves the published minimal Gray and Go fixtures met the stated same-host qualification points. It does not prove the same outcome for every framework, dependency graph, payload, or production topology.
Choose one stable Go boundary, preserve its contract, run Gray beside it, and compare correctness, tail latency, capacity, memory, failure handling, deployment, and rollback under production-shaped traffic before moving the route.
Claims and details
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.
Published and reviewed by Grayworth Engineering · 2026-07-26
Related decisions
Evaluate Gray for a selected service or workload.