What's implemented in U today

The short version

U is a real compiler that produces real C binaries from real U source code. The tokenizer, parser, linter, and codegen are working. The generated C compiles with GCC and runs. The type system catches null dereferences, capability violations, injection, and race conditions at compile time. Three transpilers convert PHP, JavaScript, and Python to U with source maps. The capability analysis engine scans codebases of 389,000 lines with zero errors.

What U is ready for today: analyzing existing codebases (transpile → analyze → report), writing new U programs that compile to C, and teaching the language to LLMs (the 1,600-token primer produces 96% compile rates on frontier models).

What U is not yet ready for: replacing a production web framework at scale. The standard library needs more bindings, the webserver is 2,600 lines of U against Qbix's 22,800 lines of battle-tested PHP, and the async event loop isn't wired to the fiber scheduler. But the core language, type system, codegen, template tags, MVCC, and AI integration are working.

The compiler

The U compiler is written in Python. It processes U source through four stages: tokenize → parse → lint → codegen. Each stage is independently testable.

What compiles end-to-end (U → C → GCC → binary → runs)

The C runtime

14,735 lines of C in u_runtime.h, plus 10,071 lines across 30+ header modules. A single-header design — include it and the generated C compiles.

Transpilers

Three source-to-U transpilers with V3 source maps (VLQ encoding). Every generated U line traces back to the original source file and line number.

The PHP transpiler handles: classes, interfaces, traits, namespaces, closures, arrow functions, match expressions, named arguments, null-safe operator (?->), spread, fibers, dynamic instantiation, variable variables, pass-by-reference, heredocs, and 1,246 PHP stdlib function mappings.

Capability analysis

785 lines of JavaScript. Five layers of inference, each catching what the others miss:

Tested against Laravel (10/10 functions correct), Symfony (9/9 correct), and the full Qbix Platform (2,359 files, zero false positives on pure modules).

The analysis produces a capability breakdown of any codebase: which modules are pure, which touch the filesystem, network, database, crypto, or shell. The Qbix Platform result: 75.5% pure, 12.4% +IO, 10.6% +DB, 3.8% +Crypto, 2.2% +Net, 1.2% +Exec.

The webserver

The U webserver (github.com/ULanguageOrg/webserver) is 4,660 lines of U across 34 source files (28 modules + 6 example apps). The Qbix PHP webserver (github.com/Qbix/webserver) is the production reference at 22,788 lines.

U webserver — 28 modules, 3,577 lines

Complete parity achieved

Edge-case coverage: the PHP modules have years of production edge-case handling (chunked encoding, SNI, OCSP stapling, .htaccess parsing, multipart boundary detection) that the U versions handle at a structural level but don't yet cover every corner case. This is the kind of gap that closes with real-world usage.

The site

39 HTML pages with consistent navigation (5 dropdown menus: Learn, Build, Docs, Platform, Safebox). Mobile hamburger menu. All markdown docs rendered as styled HTML. 45 internal links, zero dead. Safebots dark theme.

Key pages: Why U (20 sections), Analysis Engine, Comparison, Possibilities, Formats (string/template reference), Language Spec, Tutorial, Playground.

The full pipeline

This works today, end to end:

$ cat hello.u
f greet(name: S) -> S
    r => "Hello, {{name}}!"

f main() -> I
    log(greet("world"))
    r => 0

$ u2c compile hello.u -o hello.c   # U → C
$ gcc hello.c -o hello -lm          # C → binary
$ ./hello
Hello, world!                         # runs

And this works for analysis:

# Transpile a PHP codebase to U:
curl -X POST compiler.ulanguage.org/compile?source_type=php \
  -d @MyApp.php

# The capability analysis shows:
75.5% pure | 12.4% +IO | 10.6% +DB | 2.2% +Net

What's missing

An honest list of what doesn't work yet or isn't finished:

How to use U today

1. Analyze existing codebases

Transpile your PHP, JavaScript, or Python code to U. Get a capability report that tells you what each module does — filesystem, network, database, crypto, shell — with every finding traced back to the original source line. No code changes needed.

2. Write new U programs

The compiler produces working C binaries. Functions, classes, error handling, pattern matching, nullable types, maps, lists, string interpolation, SIMD — all compile and run. The type system catches null dereferences, capability violations, injection, and race conditions at compile time.

3. Teach LLMs to write U

The LLM Primer is 1,600 tokens. GPT-4o compiles 94% of the time. Claude Sonnet compiles 96%. The compiler catches the remaining bugs — 100% of null, race, and injection errors.

4. Use U inside Safebox

U is the intermediate form for Safebox — a sealed execution environment where every module carries a compiler-verified proof of its capabilities. M-of-N signing, hash-pinned compiler, attested hardware. The capability analysis is the trust boundary.

Try it

Open the Playground Compiler API docs