Write TypeScript. Symmetra compiles your route handlers into CUDA machine code — zero VM, zero GC, zero interpreter. Measured across 7 publicly-known Turing machines on a single NVIDIA L4 (GCP, 72W TDP), each on identical endpoints: 624K req/s on a trivial handler, up to 48.0B steps/sec on the heaviest one — using only 4,096 / 89,088 threads deployed (4.6% of the GPU).
GPU-native TypeScript is ready for early adopters. Compile your routes to CUDA machine code — zero friction, production performance from day one.
Symmetra's pipeline has three stages: compile your TypeScript routes to CUDA at startup, batch incoming requests into warp-aligned groups, then execute them in parallel across all 48 streaming multiprocessors with zero garbage collection.
CUDA's massively parallel architecture is what makes Symmetra's performance numbers real. See how modern GPU technology enables sub-20 µs P99 at 3.1 M req/s.
SymmParser reads your route handlers. Codegen emits device-ready CUDA C++. NVRTC JIT-compiles to PTX. cuModuleLoadData binds the cubin — all in ~200 ms at startup.
BatchScheduler groups same-route requests into warp-aligned batches. A single cuMemcpyHtoDAsync (~30 µs) uploads all 256 slots. One kernel launch fires all handlers in parallel.
Kernels run across 48 streaming multiprocessors. VRAM-resident Map, Set, and GpuBuffer serve all operations. Response serialization completes on-device. P99 under 20 µs.
Click any module to focus on that subsystem — its role, its inputs and outputs, and how it connects to the rest of the engine. The pipeline is proprietary where marked 🔒; the public surface, runtime internals, and VRAM architecture are fully documented.
Source files, route declarations, package imports, and handler code enter the system here before any GPU-specific shaping begins.
Entry surface for TypeScript servers, routes, and program structure.
Source -> stripped JS -> routable AST.
server.ts, packages/http/src/index.ts
Each incoming request passes through CPU admission, warp-aligned batching, async DMA upload, parallel GPU kernel execution, and on-device response serialization before returning. This diagram makes every handoff explicit — no hidden magic.
ThreadPool owns TCP accept, recv, and admission shaping. Pinned memory enables zero-copy DMA.
GpuServer → GpuWorker → GpuAllocator → kernels. All execution stays on-device.
JavaScript runtimes, Python interpreters, and JVM bytecode all add overhead. Symmetra eliminates the middle-tier — your TypeScript compiles directly to CUDA, executes on silicon, and returns results in microseconds instead of milliseconds.
Traditional JS: TypeScript → JS → Parse → Compile → Tier 2 JIT → Execute · With GC pauses every ~50ms
Symmetra: TypeScript → CUDA AST → NVRTC JIT → PTX → cubin → Execute (on GPU) · Zero GC, zero pauses, deterministic latency
Result: Microsecond-scale handler execution with deterministic latency — no JIT warm-up, no GC pauses, ever.
GPU strengths: 48 cores (SMs), 384 threads per core (warps), 20GB/s GDDR memory, hardware concurrency
Symmetra leverages: Warp-aware batching, VRAM-resident containers (Map, Set, GpuBuffer), 32 concurrent CUDA streams, lock-step execution
Result: One API across multiple engine families. The GPU sits at <2% utilization at current request rates — enormous compute headroom.
CPU challenges: GC pauses, context switching, cache misses, thermal throttling
Symmetra guarantees: O(1) slab allocation, fixed-size batches, warp lock-step, O(1) teardown
Result: tight latency distributions in our load tests — no GC-induced tail spikes, because there is no GC.
7 published Turing machines benchmarked on identical hardware and endpoints — Rule 60, Rule 110, Wolfram (2,3), and 4 more universal machines. wolfram23 ships publicly today; the rest are measured reference results.
No code changes: the HTTP API stays the same — engines differ only in the computation their handlers run.
Result: the same route shape works whether the handler runs a 1-state TM or a 786,432-step cyclic tag system.
Crypto on GPU: AES-256-GCM, SHA-256, HMAC running on GPU threads · No CPU context switch for encryption
Data isolation: VRAM is device memory. No system RAM copy. Bounds-checked kernels prevent buffer overflows.
Result: crypto work runs on GPU threads instead of stealing CPU cycles from your I/O path.
Your existing TypeScript: Express-compatible API. Standard async/await. Familiar Router patterns.
One command: sym ./server.ts compiles, links, launches
Result: No CUDA knowledge required. Ship GPU apps in minutes, not weeks.
~600K req/s on trivial handlers, up to 48.0B GPU steps/sec on the heaviest, across 7 published Turing machines — all on a single NVIDIA L4, 4.6% of its thread capacity deployed. Full numbers and per-engine breakdowns are just below.
Every number below is from our published cloud benchmark: 7 publicly-known Turing machines, all on a single NVIDIA L4 (GCP, 58 SMs, 72W TDP), same server, same identical endpoint ladder, same day. Full per-engine reports →
| Route | Computation per request | Req/s | p50 latency |
|---|---|---|---|
| /health | Trivial JSON — baseline | 602K | 301µs |
| /light | Wolfram (2,3) UTM · 1× base scale | 472K | 292µs |
| /medium | Wolfram (2,3) UTM · 8× base scale | 366K | 308µs |
| /heavy | Wolfram (2,3) UTM · 64× base scale, 65,536 steps/req | 153K | 685µs |
| Engine | Model | Steps/sec |
|---|---|---|
| cyclotron-tag | Cyclic tag system (Cook 2004 lineage) | 48.0B |
| uni-tag2 | 2-tag system — Cocke & Minsky, 1964 | 25.3B |
| rule-60 | Rule 60 elementary cellular automaton | 24.0B |
| uni-smith3 | 3-state UTM — Lin & Rado, 1965 | 20.3B |
| uni-wolfram23 | Wolfram (2,3) UTM — Alex Smith, 2007 | 10.0B |
wolfram23 is the only publicly downloadable engine right now. The other 6 in our cloud benchmark are reference results — measured, published, not yet re-opened for download.
Codegen, runtime, scalability, robustness, and memory-safety suites. No leaks detected in testing.
4,096 of 89,088 L4 threads deployed. The CPU's network I/O is the bottleneck on light routes — the GPU has room to spare.
Slab allocator resets in O(1). No heap, no garbage collector, no GC-induced jitter spikes.
Your routes JIT-compile to PTX at startup (typically a few hundred ms). After that, every request hits pre-compiled GPU machine code. No warm-up tiers, no interpreter fallback.
Some JavaScript patterns aren't supported by the codegen yet (see constraints). Only wolfram23 ships publicly today; APIs may change between releases.
Pre-shared key AEAD authenticated encryption. Hardware-accelerated on GPU. Zero overhead for encrypted workloads.
CUDA device memory access is bounds-checked. No buffer overflows. No unsafe pointer arithmetic on the hot path.
Path traversal prevention, URL sanitization, and defensive JSON parsing — all running on GPU threads.
Shared state protected by mutex and atomic operations. No data races in 870+ assertion test suite.
TypeScript AST → CUDA C++ → NVRTC JIT → PTX → cubin. No VM, no interpreter, no bytecode.
Map, Set, and GpuBuffer — open-addressing hash tables in GDDR7. ~20× faster than CPU DDR5.
JSON parsing, transformation, and serialization run on GPU threads in parallel across all 256 batch slots.
Promise.all([a,b,c]) launches 3 independent CUDA streams — hardware parallelism, not event-loop fan-out.
Router, Context, serve() — drop-in Express-compatible server API that compiles to GPU.KvStore, Map, Set, and typed GpuBuffer with GPU-side CRUD semantics.sym ./server.ts compiles, links, and launches. sym doctor verifies GPU, CUDA, and NVRTC prerequisites.Same NVIDIA L4, same identical endpoint ladder, same day (2026-07-08). /heavy steps/sec, ranked. Full reports →
Model: Cyclic tag system — Cook 2004 lineage, the construction behind Rule 110's universality proof
Measured: 61,011 req/s on /heavy, NVIDIA L4, GCP
Model: 2-tag system — proven universal by Cocke & Minsky, 1964
Measured: 32,151 req/s on /heavy, NVIDIA L4, GCP
Model: Rule 60 elementary cellular automaton — draws a Sierpiński pattern
Measured: 195,687 req/s on /heavy, NVIDIA L4, GCP
Model: 3-state universal Turing machine — Lin & Rado, 1965
Measured: 206,858 req/s on /heavy, NVIDIA L4, GCP
Model: Wolfram (2,3) UTM — Alex Smith, 2007, $25,000 Wolfram Prize; smallest known universal Turing machine
Measured: 152,645 req/s on /heavy, NVIDIA L4, GCP — the only engine publicly downloadable right now
/health — trivial
~600K req/s across every engine — pure request plumbing, the CPU's network I/O is the limit, not the GPU.
/light and /medium
365K–520K req/s — engines start to diverge as per-request GPU work grows.
/heavy — 64× base scale
32K–250K req/s, up to 48.0 billion Turing-machine steps/sec — this is where the GPU does real work and engines differentiate.
Disclosure: All figures measured on a single NVIDIA L4 (GCP, 58 SMs, 72W TDP), wrk as load generator (16 threads × 300 connections, 20s window), with each handler executing on 4,096 of the L4's 89,088 threads (4.6% deployed). Of these 7 engines, only wolfram23 is currently publicly downloadable — the rest are measured, published reference results. Symmetra is beta software; benchmark results are observations from this configuration, not commitments.
All measurements taken on the same NVIDIA L4 (GCP), same day. No extrapolations — every one of these is a published, citable result from computability theory. Full reports →
| Algorithm | /health RPS | /heavy RPS |
|---|---|---|
| uni-chronos (1-state halting TM) | 624K | 249K |
| uni-rule110 (Rule 110 CA, universal) | 623K | 173K |
| uni-tag2 (2-tag system, universal) | 621K | 32K |
| wolfram23 (Wolfram (2,3) UTM) · ships today | 602K | 153K |
| uni-smith3 (3-state UTM, universal) | 596K | 207K |
| rule-60 (elementary cellular automaton) | 598K | 196K |
All measurements: wrk load generator (16 threads × 300 connections, 20s window), single NVIDIA L4 (GCP), 2026-07-08 — handlers on 4,096 GPU threads (4.6% of L4 capacity). Beta software — results are observations from our test rig, not guarantees.
Available to download
wolfram23 — Wolfram (2,3) UTM — the smallest known universal Turing machine, and the only engine shipping publicly today
Highest compute throughput
cyclotron-tag — 48.0B Turing-machine steps/sec on /heavy, our top-measured engine
Learning the model
rule-60 — classic cellular automaton, easy to reason about, draws a Sierpiński pattern
Each engine is a TypeScript application whose handlers implement one specific, published Turing machine or cellular automaton — all running on the same CUDA persistent-kernel substrate, all measured on identical hardware and endpoints. wolfram23 is the only one publicly downloadable today; the rest are measured reference results. Full reports →
Installation issues? Performance questions? Language compatibility? Find answers here.
Yes. Symmetra requires an NVIDIA GPU with compute capability 7.5+ (RTX 2070 or newer). Check with nvidia-smi. CPU-only mode is not supported.
Run sym doctor for detailed diagnostics. Common issues: CUDA driver not installed, driver version too old (<525), or NVRTC not in PATH. Visit CUDA downloads to update.
That's NVRTC JIT-compiling your routes to PTX at startup — a one-time cost. After ~200ms, your server is hot and every request hits pre-compiled machine code. No warm-up needed. Bun starts faster (~70ms) but JITs requests, adding 1-2ms per new code path.
Not yet in v1.0. Each server gets exclusive GPU access. For multi-tenancy, run servers on separate GPUs or use NVIDIA MIG (multi-instance GPU) on A100/H100 hardware.
Interfaces, types, classes, async/await, generators, Promise.all/race, destructuring, template literals, spread operators, and more. Check JS/TS coverage for the full matrix. Unsupported: eval(), dynamic imports, Reflect, Proxy (coming soon).
Yes. AES-256-GCM + TLS 1.3 on GPU. Pre-shared keys for AEAD. Incoming TLS traffic offloads to GPU at wire speed. Zero CPU crypto overhead.
No. Route handlers compile entirely to CUDA. If you need CPU code (legacy libraries, system calls), run that on a separate CPU service and call it via HTTP from your Symmetra routes.
Install Symmetra on your GPU server, run sym ./server.ts, and bind to a stable port (default 8080). Reverse-proxy with Nginx/HAProxy in front. Docker support coming in v1.1.
VRAM is volatile. Use @symmetra/db for in-memory caches, but connect to persistent storage (PostgreSQL, Redis, S3) for durable data. VRAM is 10-100× faster than disk.
Minimum 2GB (RTX 2070). Batch size 256 uses ~1.5GB for request buffers + containers. Larger models and caches need more. RTX 5070 has 12GB: plenty for most workloads. Profile with sym benchmark.
Symmetra is free to use during the public beta for evaluation, research, and non-critical services. Full license terms are included with every engine download. Commercial licensing details will be announced before general availability.
Sign in and open a ticket on the Support page — you can file it against the specific engine you downloaded. Include: OS, driver version (nvidia-smi), your server.ts code, and error logs. Run sym debug server.ts > debug.log for detailed traces.
Open a ticket on the Support page with detailed logs, or ask the community in Discussions.
Full architecture reference, JS/TS language coverage matrix, getting started guide — all available below.
Definitions for common performance and GPU terms used throughout the site.
The number of HTTP requests a server can handle per second under sustained load. Higher RPS indicates greater throughput capacity. Example: 47K req/s means 47,000 requests per second.
The response time for the 99th percentile of requests (only 1% of requests are slower). This measures the worst-case performance for most users. We publish p50 (median) figures alongside test conditions so you can interpret them honestly.
The automatic process of freeing unused memory. Most runtimes (Node.js, Python, JVM) pause execution during GC, causing latency spikes. Symmetra uses manual memory management with zero GC pauses.
A measure of computational throughput for Turing machine engines: how many TM state transitions execute per second. We report these per-engine on the engines page, with the exact machine counts and tape sizes used.
The time taken for a server to start up and be ready to handle requests. Symmetra's ~200ms cold start is spent JIT-compiling your TypeScript routes to CUDA machine code. After that, every request hits pre-compiled code.
Continuous, steady request traffic over an extended period. All Symmetra benchmarks are measured under sustained load (not peak burst), reflecting real-world production conditions. Sustained throughput is more reliable than peak RPS.
Video RAM on the GPU. Symmetra stores request buffers, containers (Map, Set), and GPU state in VRAM. RTX 5070 has 12GB; RTX 2070 has 8GB. VRAM is 10-100× faster than system RAM.
A theoretical model of computation: a tape, a read/write head, and a state-transition table. Symmetra compiles each route handler into one, then runs it as a persistent CUDA kernel. See the engine catalog for the 7 published machines we've benchmarked.