U takes the PHP, JavaScript, Python, or TypeScript you already write and compiles it to native binaries and WebAssembly. No rewrite. No framework. Your existing codebase, running 10–80× faster, in a single portable binary with zero runtime dependencies.
Paste PHP, JavaScript, TypeScript, or Python into the playground. It transpiles to U as you type. Hit Compile to get C, or Run to execute as WebAssembly in your browser. Nothing to install.
Upload a zip of your project. The transpiler handles classes, closures, async/await, generators, decorators, type hints, and the standard libraries you actually use. 943 Qbix Platform PHP files transpile cleanly.
The compiler produces portable C that builds with any C compiler. gcc, clang, MSVC, Cosmopolitan (one binary, every OS), or wasi-sdk for WebAssembly. The output starts in microseconds, not the 200ms cold-start of a runtime.
The same code that runs as a native binary also runs as WASM in any browser. The server compiles U→C→WASM via wasi-sdk and returns the binary. Your browser sandbox executes it — the server never runs your code.
Add +V to a list operation and the compiler emits a WGSL compute shader. The browser dispatches it to the GPU via WebGPU. Same shader runs on Vulkan, Metal, and D3D12 — one annotation, every GPU.
U's modifiers replace config files and framework boilerplate. +R puts data on the heap. +M makes it mutable. +N makes it nullable. +V vectorizes it. +A makes it async. The compiler enforces the rest.
The left side is what you write. The right side is what the transpiler produces. Both compile to the same binary.
function greet(name: string): string { return "Hello, " + name + "!"; } function fib(n: number): number { if (n < 2) return n; return fib(n - 1) + fib(n - 2); }
f greet(name: S) -> S r => "Hello, " + name + "!" f fib(nn: I) -> I nn <= 1 & r => nn r => fib(nn - 1) + fib(nn - 2)
class Dog: def __init__(self, name: str, age: int = 0): self.name = name self.age = age def speak(self) -> str: return f"woof from {self.name}"
d Dog name: S age: I +M = 0 f speak() -> S r => `woof from {{t.name}}`
Most of the world's working code is in PHP, JavaScript, and Python. It runs behind interpreters that start slow, use 10–50× more memory than necessary, and can't run on the GPU. Rewriting it in Rust or C++ isn't realistic for most teams.
U sits in the gap. It reads like the languages you know, compiles to the targets you need (native, WASM, GPU), and the transpiler handles the migration so you don't have to rewrite from scratch.
Where other languages use separate systems for memory management, concurrency, and optimization, U uses a single mechanism: type modifiers. A modifier is a + or - suffix on a type that tells the compiler what to do.
+M — mutableBindings are immutable by default. +M opts in to mutation. The compiler tracks what changes and enforces it.
+R — heap (reference)Data lives on the stack by default. +R moves it to the heap with automatic reference counting. No garbage collector.
+N — nullableValues are non-null by default. +N opts in to null, and ?. chains handle it safely. No null pointer exceptions at runtime.
+V — vectorizedList operations with +V auto-vectorize to SIMD on CPU, or compile to WGSL compute shaders for GPU execution via WebGPU.
+A — asyncFunctions marked +A are coroutines. a (await) suspends them. The runtime multiplexes thousands on one thread via an event loop.
+W — generatorFunctions that w (yield) values are generators. They produce sequences lazily, one value at a time.
U has a built-in Tree type for nested, string-keyed data — like JSON, but with methods. It's a direct port of the battle-tested Q_Tree from the Qbix Platform (8 million users, 95 countries).
config.get(["db", "host"], "localhost") walks the path with a default. config.expect(["db", "host"]) crashes if missing — for required fields.
a.b = val strict (crash if missing). a?.b = val guard (no-op if missing). a.b =! val vivify (create intermediates).
a.diff(b) computes changes. a.merge(patch) applies them. The << operator does an MVCC-safe merge — readers never see partial state.
1. Transpile — your PHP/JS/Python parses via tree-sitter (WASM) in the browser. The AST walks produce U source. This runs entirely client-side, instantly as you type.
2. Compile — the U source posts to the compile service. The Python compiler lints, type-checks, and emits C with a full runtime (8,800 lines: strings, lists, maps, trees, JSON, crypto, regex, networking, event loop).
3. Build — gcc produces a native binary. Or wasi-sdk produces WebAssembly. Or Cosmopolitan produces a single binary that runs on Linux, macOS, and Windows without recompilation.
4. Run — native binaries run directly. WASM runs in the browser sandbox. GPU kernels dispatch via WebGPU. The server never executes your code — it's a pure compiler.
The fastest path is the playground. Paste your code, see U, hit Run. Nothing to install, nothing to configure.
To compile on your own machine, the compiler is a Python service behind an HTTP API. POST /compile with U source, get C back. POST /wasm for WebAssembly.