Retrieved article excerpt
Open article · Retrieved 2026-09-11T21:22:01.514532+00:00
Menu ✕ Learn Overview Tutorial Snippets vs Other Languages Build Editor Playground Compiler API Docs Language Spec Formats u keyword Dataframe AI Library Feature Status Platform Server About Transpilation Web & Templates Safebox Why U Analysis Engine Comparison Possibilities Compiles to portable C A safer programming language for people and AI agents to collaborate on code bases more effectively. U compiles to C. The safe path and the fast path are the same path.
Write the obvious code — the compiler handles memory, concurrency, and vectorization.
No garbage collector, no data races, no ceremony. LLMs generate correct U on the first try
because the defaults are already safe. Try it in the browser Learn U Compare to Other Languages the whole idea // Zero annotations = safest + fastest defaults f process(data: [N], label: S) -> Stats
total = data.reduce((acc, v) => acc + v, 0.0) r => { total, mean: total / data.len, label } // -R: stack. -M: immutable. -N: non-null. Zero cost. // Injection is a type error, not a runtime filter f get_user(id: I) -> User ! DbError // typed errors row = db.query(SQL`SELECT * WHERE id = {{id}}`) r => User(row) // db.query("SELECT * WHERE id=" + id) → compile error // MVCC: no locks, no deadlocks << (
sender << { balance: sender.balance - amount }
recipient << { balance: recipient.balance + amount }
) // atomic: both succeed or neither does // AI-managed function — compiler checks the contract /// Rank by relevance. Prefer exact matches. u f search(q: S, items: [Product]) -> [Product] // Capabilities propagate — no hidden side effects f +E(+DB +Net) sync_users() -> I ! AuthError
users = db.fetch_all() x [] // typed fallback users.on(u => api.push(u)) // +Net propagates up r => users.len 100% Null/race/injection bugs caught 96% LLM compile rate from primer 13 Keywords (total language) 389K PHP lines transpiled (0 errors) LLMs introduced null dereferences 23% of the time and capability violations 31% of the time. The U compiler caught every one. The compiler is an uncorrelated red team — it does not hallucinate, does not miss paths, does not tire. Your existing code. Native speed. No rewrite. U is a transpilation target. Drop in a PHP, JavaScript, or TypeScript codebase.
The transpiler converts it to U. The compiler compiles U to C. GCC compiles C to a native binary.
What you get back is a compiled program that serves HTTP, not an interpreter running your code. $ # Real pipeline — tested, benchmarked php-to-u.js classes/*.php handlers/*.php → app.u u2c app.u → app.c (59KB) gcc -O2 app.c → app (22KB binary) $ ./app Qbix Demo on http://0.0.0.0:8080 Routes: / /api/users /health BENCHMARKED 7× faster than PHP. 27× on some routes. A real 8-file PHP app — classes, request/response, user model, route handlers —
transpiled through the pipeline and benchmarked against the original.
The compiled binary serves 14,275 req/s on /health and 5,689 req/s on /api/users .
PHP 8.3 does 800 req/s on the same workload. Node.js does 2,444.
These are measured numbers, not projections. 22KB Your entire app is smaller than a favicon. No V8 (60MB). No PHP interpreter (30MB). No node_modules.
The compiled binary is a single file with zero dependencies.
It starts in microseconds, uses 2MB of RAM, and fits in an L2 cache.
Deploy it to a container, a Lambda function, an edge node, or an IoT device.
Ship it by email. 1,246 FUNCTIONS Full PHP and Node.js API coverage. The transpiler maps 1,246 PHP functions — 132 to native U operations (fast path),
1,114 through a bridge to the real PHP C implementation (compatible path). strlen becomes a pointer subtraction. gzdeflate calls
the actual zlib. Your code doesn't change; the runtime underneath does. ARENA Zero memory leaks by construction. Every request gets an arena — a single block of memory that all allocations
come from. When the request ends, one pointer reset frees everything.
No reference counting, no garbage collector, no individual free() calls.
The arena allocates at 406M ops/s — 200× faster than malloc.
PHP-FPM's request isolation, without forking. 293 TESTS Every edge case, tested. 122 PHP edge cases (string, math, array, type, control flow, OOP, operators).
100 JS edge cases (array methods, string methods, classes, modern JS, TypeScript).
46 transpiler mapping tests. 4 compatibility bridge tests. 636 compiler tests.
Every run: zero failures. COW SNAPSHOTS Faster than PHP-FPM, works on Windows. Preload your classes, config, and routes once at startup. Take a snapshot.
Each request gets a copy-on-write view — reads are free, writes go to the
request arena. No fork() syscall, no process overhead, no TLB flush.
Simulated pcntl_fork() via threads gives PHP fork semantics
on Linux, macOS, and Windows. About transpilation Try it now Benchmark: compiled vs interpreted Same app logic, same routes, same JSON output. Real measurements with Apache Bench. Server req/s Binary vs PHP Compiled (from PHP) 70,026 22 KB 87× Compiled (from JS) 65,374 22 KB 82× Node.js http 2,444 ~60 MB 3× PHP 8.3 -S ~800 ~30 MB 1× Workload: /api/users — build 50 User objects, paginate, serialize to JSON, serve over HTTP with keep-alive. Compiled binaries from hand-written C equivalents. Real transpiled pipeline with arena: 21K req/s (/api/users), 17K req/s (/health) — 26× PHP, 7× Node. Who this is for PHP TEAMS Ship your Laravel/Qbix app as a binary Keep writing PHP. The transpiler handles the conversion. Your 8-file Qbix app
becomes a 22KB binary that serves 70K req/s. No PHP-FPM, no opcache tuning,
no memory_limit headaches. The arena allocator gives you PHP's per-request
isolation without the fork overhead. NODE TEAMS Ship your Express app without Node Your Express routes, middleware, and models compile to native code.
CORS headers, request logging, JSON serialization — all compiled.
65K req/s instead of 2.4K. No node_modules directory, no V8 memory
overhead, no event loop blocking. The binary is 22KB. EDGE / IOT Web apps on constrained devices A 22KB binary runs anywhere — Cloudflare Workers, AWS Lambda, a Raspberry Pi,
a smart thermostat. It starts in microseconds and uses 2MB of RAM.
Your entire API fits in a Docker scratch container with nothing else in it.
No runtime to install, no interpreter to patch, no CVEs to track. HOSTING Serve 87× more users on the same hardware A $5/month VPS running compiled PHP serves the traffic that would normally
need a $50/month setup. Or run 87 tenants where you used to run one.
The compiled binary uses a fraction of the memory and none of the
per-request startup cost that PHP-FPM charges. SECURITY Ship binaries, not source code Compiled binaries are hard to reverse-engineer. Your business logic,
database schema, and API keys don't ship as readable source.
The compiler's capability system flags credential exfiltration
and SQL injection at compile time. The binary is the security boundary. MIGRATION Start today, rewrite never You don't need to learn U to use U. The transpiler converts your existing
PHP or JS codebase. Where the transpiler can't handle an edge case (6 corrections
for an 8-file app), you hand-correct once and commit. As the transpiler improves,
those corrections disappear. Your PHP knowledge is the starting point, not a liability. Safebox: pristine environments that understand your code Apple rejects apps that call undeclared private APIs. U does the same thing — at compile time,
for every possible side effect, and with cryptographic proof that the check happened. Apple's model You declare entitlements. The App Store reviews your binary.
If you call _LSOpenURLsWithRole without declaring it, you're rejected.
But this is a review — it happens after you build, it can miss things,
and the sandbox is a runtime fence that sufficiently motivated code can probe. U + Safebox Functions declare +E(DbRead, HTTP) — their exact effects. The compiler
rejects code that calls outside its grant. This isn't a review; it's a proof .
The compiled binary physically cannot make an unauthorized network call because
the instructions don't exist in it. There's nothing to probe. What the compiler enforces — before anything runs Effect isolation A function with +E(DbRead) can read the database
but can't write to it, can't make HTTP calls, can't touch the filesystem.
A function with no +E is pure — zero side effects, guaranteed. Transitive closure If processOrder calls sendEmail ,
the compiler requires processOrder to declare +E(Email) .
Capabilities propagate up the call graph. Nothing hides. Exfiltration detection DbRead + HTTP on the same call path = data exfiltration vector.
The compiler flags it. DbRead + Email = same. The dangerous combination is
caught at compile time, not in a post-breach audit. Why this matters for AI and autonomous code When an LLM writes code, or when a plugin runs inside your application, or when third-party
code executes in your infrastructure — you need to know what it can do. Sandboxes are runtime
fences; they stop bad behavior after it starts. Capabilities are compile-time proofs; the bad
behavior can't be compiled into existence. Safebox runs compiled U code in a pristine environment. The environment doesn't need a complex
sandbox because the binary's capability manifest is a cryptographically signed proof of what
the code does. The runtime just verifies the signature and runs the code. If the manifest says +E(DbRead, Config) and nothing else, that's all the binary can do — not because
of a fence, but because of the instruction set. This is the difference between "we reviewed the code and didn't find anything bad" and
"the code structurally cannot do anything bad." The first is an opinion. The second is a proof. Read about Safebox How U powers Safebox What makes U different Every safety property comes from one system: modifiers on types. No separate borrow checker,
no async runtime, no SIMD intrinsics to learn. One mechanism, six benefits. MEMORY No garbage collector — cycles prevented at compile time Variables live on the stack by default — fast, automatic, freed when the
function returns. When you need a value to outlive the function, add +R and the compiler tracks who's using it (like Swift's ARC).
Circular references — the classic memory leak — are caught at compile time,
not at runtime. No garbage collector, no pauses, no manual memory management. CONCURRENCY Async without splitting your code in two Prefix any call with a to run it as a fiber — a lightweight
async task. There's no async/await split, no colored functions,
no thread pool boilerplate. A function that works synchronously works
asynchronously too — the caller decides, not the definition. Fibers suspend
and resume automatically; the compiler handles the scheduling. PARALLELISM SIMD without intrinsics Add +V and the compiler processes your data in parallel lanes
automatically. The emitted C uses vector types that become SSE or AVX on
x86, NEON on ARM, and WebAssembly SIMD in the browser. You don't write
intrinsics or platform-specific code — just annotate the data. If the
operation can't safely vectorize, you get a compile error, not a silent
wrong result. GPU GPU compute without CUDA +R(GPU) puts data in device memory and turns a .map() into a GPU compute shader. The same code runs in the
browser through WebGPU and natively through Dawn — one source file, every
device. No CUDA toolkit, no separat