{
  "schema": "grayworth.comparison-index.v1",
  "publisher": "Grayworth",
  "canonical": "https://grayworth.com/compare",
  "published": "2026-07-26",
  "disclosure": "Grayworth develops Gray. Measured status is true only for counterparts included in the same-host formal dataset.",
  "methodology": "https://grayworth.com/compare/methodology",
  "dataset": "https://grayworth.com/data/http-comparison-results.json",
  "comparisons": [
    {
      "name": "Gray vs Go",
      "counterpart": "Go",
      "url": "https://grayworth.com/compare/go",
      "measured_same_host": true,
      "short_answer": "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.",
      "sources": [
        {
          "label": "Grayworth same-host research",
          "url": "https://grayworth.com/research"
        },
        {
          "label": "Download the formal comparison dataset",
          "url": "https://grayworth.com/data/http-comparison-results.json"
        },
        {
          "label": "Go concurrency and goroutines",
          "url": "https://go.dev/doc/effective_go#concurrency"
        }
      ]
    },
    {
      "name": "Gray vs Node.js",
      "counterpart": "Node.js",
      "url": "https://grayworth.com/compare/nodejs",
      "measured_same_host": true,
      "short_answer": "Choose Gray when a backend needs the immediacy developers like in Node.js without making the application carry the event loop's continuation discipline. Gray's tested qualifying ceiling reached 60k/s on both published routes, versus 12k/s plaintext and 20k/s JSON for Node.js in the same fixture.",
      "sources": [
        {
          "label": "Grayworth same-host research",
          "url": "https://grayworth.com/research"
        },
        {
          "label": "Download the formal comparison dataset",
          "url": "https://grayworth.com/data/http-comparison-results.json"
        },
        {
          "label": "Node.js: do not block the event loop",
          "url": "https://nodejs.org/en/learn/asynchronous-work/dont-block-the-event-loop"
        }
      ]
    },
    {
      "name": "Gray vs PHP",
      "counterpart": "PHP",
      "url": "https://grayworth.com/compare/php",
      "measured_same_host": true,
      "short_answer": "Choose Gray when you want PHP-like directness on a persistent native server platform. Live and Adaptive execution preserve the fast development loop while Gray's reactor and cooperative PostgreSQL path replace the request-process ceiling. In the published fixture, Gray's highest qualifying rate was 7.5 times PHP-FPM's on both routes.",
      "sources": [
        {
          "label": "Grayworth same-host research",
          "url": "https://grayworth.com/research"
        },
        {
          "label": "Download the formal comparison dataset",
          "url": "https://grayworth.com/data/http-comparison-results.json"
        },
        {
          "label": "PHP FastCGI Process Manager",
          "url": "https://www.php.net/fpm"
        },
        {
          "label": "PHP-FPM pool configuration",
          "url": "https://www.php.net/manual/en/install.fpm.configuration.php"
        }
      ]
    },
    {
      "name": "Gray vs Rust",
      "counterpart": "Rust",
      "url": "https://grayworth.com/compare/rust",
      "measured_same_host": false,
      "short_answer": "Choose Gray for product-facing server software that should feel direct, deploy live, and own its HTTP, TLS, database, tooling, and selective native execution as one platform. Gray delivers the server product above the systems layer instead of asking every application team to assemble it.",
      "sources": [
        {
          "label": "Gray native backend status",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "The Rust Programming Language: ownership",
          "url": "https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html"
        },
        {
          "label": "Rust Send and Sync",
          "url": "https://doc.rust-lang.org/stable/book/ch16-04-extensible-concurrency-sync-and-send.html"
        }
      ]
    },
    {
      "name": "Gray vs Java",
      "counterpart": "Java",
      "url": "https://grayworth.com/compare/java",
      "measured_same_host": false,
      "short_answer": "Choose Gray for a focused backend that wants readable synchronous code without carrying a conventional JVM service stack. Compiler-hidden continuations, native networking, Adaptive replacement, and a compact Static artifact make the runtime part of the product instead of another platform to assemble.",
      "sources": [
        {
          "label": "Gray asynchronous contract",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "Oracle virtual threads guide",
          "url": "https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html"
        },
        {
          "label": "Oracle concurrency overview",
          "url": "https://docs.oracle.com/en/java/javase/21/core/concurrency.html"
        }
      ]
    },
    {
      "name": "Gray vs Python",
      "counterpart": "Python",
      "url": "https://grayworth.com/compare/python",
      "measured_same_host": false,
      "short_answer": "Choose Gray for the performance-critical API boundary while keeping Python where its data, AI, and automation ecosystem creates value. Gray turns that hot path into a compact, typed server product with native HTTP, cooperative PostgreSQL, and bounded native execution.",
      "sources": [
        {
          "label": "Gray engineering overview",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "Python asyncio documentation",
          "url": "https://docs.python.org/3/library/asyncio.html"
        },
        {
          "label": "Python coroutines and tasks",
          "url": "https://docs.python.org/3/library/asyncio-task.html"
        }
      ]
    },
    {
      "name": "Gray vs C#",
      "counterpart": "C# / .NET",
      "url": "https://grayworth.com/compare/csharp",
      "measured_same_host": false,
      "short_answer": "Choose Gray when a service benefits from a smaller integrated runtime, synchronous-looking cooperative handlers, Adaptive replacement, and a deployment artifact Grayworth can optimize as one system. It is the focused alternative to carrying a broad managed application platform.",
      "sources": [
        {
          "label": "Gray asynchronous server design",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "Microsoft C# async and await",
          "url": "https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/"
        },
        {
          "label": "ASP.NET Core fundamentals and Kestrel",
          "url": "https://learn.microsoft.com/en-us/aspnet/core/fundamentals/"
        }
      ]
    },
    {
      "name": "Gray vs Ruby",
      "counterpart": "Ruby",
      "url": "https://grayworth.com/compare/ruby",
      "measured_same_host": false,
      "short_answer": "Choose Gray for a server path that should keep Ruby's belief in expressive application code while gaining an integrated reactor, cooperative database I/O, Adaptive replacement, and selective native execution. Port the pressure boundary and leave the product surface intact.",
      "sources": [
        {
          "label": "Gray platform overview",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "Ruby for developers from other languages",
          "url": "https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/"
        },
        {
          "label": "Ruby YJIT documentation",
          "url": "https://docs.ruby-lang.org/en/3.3/yjit/yjit_md.html"
        }
      ]
    },
    {
      "name": "Gray vs C++",
      "counterpart": "C++",
      "url": "https://grayworth.com/compare/cpp",
      "measured_same_host": false,
      "short_answer": "Choose Gray when the product needs native server performance without turning application development into manual systems engineering. Gray selectively lowers eligible code, preserves VM fallback, and owns HTTP, TLS, PostgreSQL, cancellation, deployment, and developer tooling as one commercial platform.",
      "sources": [
        {
          "label": "Gray native backend",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray performance research",
          "url": "https://grayworth.com/research"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "Standard C++ foundation",
          "url": "https://isocpp.org/get-started"
        }
      ]
    },
    {
      "name": "Gray vs Kotlin",
      "counterpart": "Kotlin",
      "url": "https://grayworth.com/compare/kotlin",
      "measured_same_host": false,
      "short_answer": "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.",
      "sources": [
        {
          "label": "Gray cooperative I/O",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "Kotlin server-side overview",
          "url": "https://kotlinlang.org/docs/server-overview.html"
        },
        {
          "label": "Kotlin coroutines guide",
          "url": "https://kotlinlang.org/docs/coroutines-guide.html"
        }
      ]
    },
    {
      "name": "Gray vs Elixir",
      "counterpart": "Elixir",
      "url": "https://grayworth.com/compare/elixir",
      "measured_same_host": false,
      "short_answer": "Choose Gray when the service priority is compact native execution, low tail latency, direct handlers, and readiness-driven HTTP and PostgreSQL. Gray turns those capabilities into one commercial server platform with Live, Adaptive, and Static operating modes.",
      "sources": [
        {
          "label": "Gray runtime architecture",
          "url": "https://grayworth.com/engineering"
        },
        {
          "label": "Gray comparison methodology",
          "url": "https://grayworth.com/compare/methodology"
        },
        {
          "label": "Elixir processes",
          "url": "https://elixir-lang.org/getting-started/processes.html"
        },
        {
          "label": "Elixir supervisors and applications",
          "url": "https://elixir-lang.org/getting-started/mix-otp/supervisor-and-application.html"
        }
      ]
    }
  ]
}