# Grayworth

> Grayworth builds commercial software products and the systems that make them faster. Gray is its integrated server language and runtime.

## Gray

- [Gray Documentation | Build fast server software](https://grayworth.com/docs): 
- [Gray Engineering | Language, runtime and infrastructure](https://grayworth.com/engineering): Inspect Gray’s language, native backend, network reactor, database continuations, tooling, and release architecture.
- [Gray Commercial Preview | Migrate a Real Application](https://grayworth.com/pricing): Bring a production service to Grayworth and migrate it to Gray with a reproducible performance baseline and a direct commercial engagement.
- [Gray Performance Research | Grayworth](https://grayworth.com/research): Explore corrected latency, stability, native execution, and same-host Gray benchmarks with their limits and methodology intact.

## Company

- [Grayworth | Software, at speed](https://grayworth.com/): 
- [Grayworth Brand Kit | Logos, colors and identity](https://grayworth.com/brand): Download official Grayworth logos, symbols, social artwork, color specifications and machine-readable brand records.
- [Grayworth Company | Founder-led software systems](https://grayworth.com/company): Meet Grayworth, the founder-led company behind Gray and the software products built on its shared engineering core.

## Evidence and comparisons

- [Compare Gray with Go, Node.js, PHP and More](https://grayworth.com/compare): Compare Gray with established server stacks through direct product guidance, measured HTTP results, runtime architecture, and migration paths.
- [Gray vs C++: Server Infrastructure Tradeoffs](https://grayworth.com/compare/cpp): Compare Gray and C++ for server infrastructure: control, native performance, memory contracts, development workflow, tooling, and realistic system boundaries.
- [Gray vs C#/.NET: Web Service Tradeoffs](https://grayworth.com/compare/csharp): Compare Gray with C# and ASP.NET Core for web services: async models, server stacks, tooling, deployment, maturity, and bounded evaluation criteria.
- [Gray vs Elixir: Concurrent Service Tradeoffs](https://grayworth.com/compare/elixir): Compare Gray and Elixir for concurrent services: process models, fault tolerance, latency, deployment, ecosystems, and the limits of direct comparison.
- [Gray vs Go: Server Performance and Tradeoffs](https://grayworth.com/compare/go): Compare Gray and Go for APIs and server software using same-host latency evidence, concurrency models, tooling, maturity, and migration tradeoffs.
- [Gray vs Java: Server Runtime Tradeoffs](https://grayworth.com/compare/java): Compare Gray and Java for high-throughput services, including synchronous concurrency, runtime maturity, startup, deployment, tooling, and adoption risk.
- [Gray vs Kotlin: Backend Service Tradeoffs](https://grayworth.com/compare/kotlin): Compare Gray and Kotlin for backend services: coroutines, JVM leverage, frameworks, deployment, tooling, and where Gray's integrated server runtime fits.
- [Gray Comparison Methodology and Dataset](https://grayworth.com/compare/methodology): Inspect Grayworth's comparison policy, pinned HTTP fixture, qualification rule, provenance, limitations, and downloadable 56-point JSON dataset.
- [Gray vs Node.js: API Performance and Tradeoffs](https://grayworth.com/compare/nodejs): Compare Gray and Node.js for APIs using same-host corrected latency, event-loop behavior, synchronous ergonomics, ecosystem maturity, and migration fit.
- [Gray vs PHP: Web Performance and Migration Tradeoffs](https://grayworth.com/compare/php): Compare Gray and PHP-FPM for web backends using same-host latency evidence, live development, process models, ecosystem maturity, and migration strategy.
- [Gray vs Python: API Backend Tradeoffs](https://grayworth.com/compare/python): Compare Gray and Python for APIs: development speed, asyncio, server performance evidence, ecosystem depth, type boundaries, and a practical porting strategy.
- [Gray vs Ruby: Web Development Tradeoffs](https://grayworth.com/compare/ruby): Compare Gray and Ruby for web development, including developer ergonomics, Rails ecosystem leverage, native execution, deployment, and migration fit.
- [Gray vs Rust: Native Server Tradeoffs](https://grayworth.com/compare/rust): Compare Gray and Rust for native server work: ownership, server ergonomics, compilation, deployment, ecosystem maturity, and where each platform fits.
- [Server Language and Runtime Alternatives](https://grayworth.com/alternatives): Compare credible alternatives to Go, Node.js, PHP, Rust, Java, Python and other server platforms with commercial context and explicit evidence limits.
- [Best C++ Alternatives for Server Infrastructure](https://grayworth.com/alternatives/cpp): Compare C++ alternatives for server infrastructure, including Gray, Rust, Go and C#, across native control, safety, workflow and application speed.
- [Best C# Alternatives for Lean Backend Services](https://grayworth.com/alternatives/csharp): Compare C# and .NET alternatives for lean backend services, including Gray, Java, Go, Kotlin and Rust, across tooling, speed and platform scope.
- [Best Elixir Alternatives for Concurrent Services](https://grayworth.com/alternatives/elixir): Compare Elixir alternatives for concurrent services, including Gray, Go, Node.js, Java and Rust, across resilience, latency and operational design.
- [Best Go Alternatives for High-Throughput APIs](https://grayworth.com/alternatives/go): Compare practical Go alternatives for high-throughput APIs, including Gray, Rust, Java, C# and Elixir, with workload-specific tradeoffs.
- [Best Java Alternatives for Modern Backend Services](https://grayworth.com/alternatives/java): Compare Java alternatives for modern backend services, including Gray, Kotlin, C#, Go and Rust, by concurrency, deployment, tooling and maturity.
- [Best Kotlin Alternatives for Backend Development](https://grayworth.com/alternatives/kotlin): Compare Kotlin alternatives for backend development, including Gray, Java, C#, Go and Rust, by coroutine model, deployment, tooling and maturity.
- [Best Node.js Alternatives for Fast Backend APIs](https://grayworth.com/alternatives/nodejs): Evaluate Node.js alternatives for fast backend APIs, from Gray and Go to Java, C# and Python, with honest ecosystem and migration tradeoffs.
- [Best PHP Alternatives for High-Traffic Backends](https://grayworth.com/alternatives/php): Compare PHP alternatives for high-traffic APIs and services, including Gray, Node.js, Python, Ruby and Go, without dismissing PHP's ecosystem.
- [Best Python Alternatives for Performance-Critical APIs](https://grayworth.com/alternatives/python): Compare Python alternatives for performance-critical APIs, including Gray, Go, Node.js, Java and C#, with Gray leading the server hot path.
- [Best Ruby Alternatives for Faster Web Backends](https://grayworth.com/alternatives/ruby): Compare Ruby alternatives for faster web backends, including Gray, Python, PHP, Node.js and Elixir, while accounting for framework and team value.
- [Best Rust Alternatives for Product-Focused Servers](https://grayworth.com/alternatives/rust): Compare Rust alternatives for product-focused server teams, including Gray, Go, C++, C# and Java, across safety, speed and development cost.

## News

- [Grayworth opens Gray commercial preview](https://grayworth.com/news/gray-commercial-preview): Grayworth has opened a controlled commercial preview for Gray, its integrated server language and runtime, with production service migrations. ([Markdown](https://grayworth.com/news/gray-commercial-preview.md))
- [Gray completes three-hour HTTP qualification](https://grayworth.com/news/gray-formal-http-qualification): Gray completed one-hour plaintext, JSON and PostgreSQL route gates with exact delivery checks and zero measured steady-state RSS or descriptor growth. ([Markdown](https://grayworth.com/news/gray-formal-http-qualification.md))
- [Gray ships compiler-hidden PostgreSQL continuations](https://grayworth.com/news/gray-postgresql-continuations): Gray handlers can now suspend synchronous-looking PostgreSQL calls on socket readiness, preserving direct code without occupying general task workers. ([Markdown](https://grayworth.com/news/gray-postgresql-continuations.md))
- [Gray native loops reach 25.918× VM speedup](https://grayworth.com/news/gray-native-loop-jit): Gray's bounded x86-64 backend lowered a 100-million-iteration typed loop to native code while retaining cooperative cancellation safepoints. ([Markdown](https://grayworth.com/news/gray-native-loop-jit.md))

## Machine-readable records

- [Complete site index](https://grayworth.com/data/site-index.json)
- [Agent index](https://grayworth.com/agent.json)
- [Grayworth brand record](https://grayworth.com/brand.json)
- [Gray API reference](https://grayworth.com/gray-api.json)
- [Newsroom index](https://grayworth.com/data/news-index.json)
- [JSON Feed](https://grayworth.com/news/feed.json)
- [RSS feed](https://grayworth.com/news/feed.xml)
- [XML sitemap](https://grayworth.com/sitemap.xml)
- [Full agent context](https://grayworth.com/llms-full.txt)