P0-12 · SELF-HOSTING · v1.1 FROZEN · NO JS

TLL OS

// an AI-native programming language and runtime
C is the match. TLL is the fuel.

A specification-driven, self-hosted language with a pure-TLL compiler, native bytecode VM, and first-class closures. Zero Node.js, zero npm, zero JavaScript in the production chain.

Get Started How it works
tllvm — live compile & run
0
opcodes · frozen
0
builtins
0
compiler functions
0
self-hosted instructions
A==B==C">0
deterministic
// Core

Built to compile itself.

The compiler, type system, and standard library are implemented in TLL. Once the C launcher is built, TLL compiles and runs itself — verified by SHA256 across generations.

⚙

Self-Hosting Compiler

Lexer, parser, typechecker, codegen, linker in pure TLL. The compiler compiles itself — deterministically, SHA256-verified across generations.

compiler/*.tll
▣

Native Bytecode VM

Register-based VM, 46 frozen opcodes, frame pool, max-register optimization. 357× faster function calls than the naive stack model.

opcode 0–45
λ

First-Class Closures

Function values, higher-order functions, mutable capture, shared UpvalueBox, escaping closures. Flat model — no chain lookups.

opcode 42–45
▤

Spec-First Architecture

The spec is the single semantic authority. Every VM — C today, Rust/Go/WASM tomorrow — is a conforming implementation.

spec/
⌘

Zero JS Runtime

No Node.js, npm, TypeScript, or JavaScript in the production chain. C is the only stage-0 — and it only touches OS boundaries.

native-only
⬡

Production HTTP

Worker-pool HTTP server, file system, JSON, time, process APIs. Dogfooded by an e-commerce platform and a 46k-tick/sec market system.

http.serve
// Bootstrap chain

The C spark. The TLL fire.

A C compiler builds tllvm once. From that point, every compilation and every execution is TLL itself.

C compiler gcc / clang / MSVC · stage-0, one time
▼
tllvm native launcher · loads .tllbc · Host ABI
▼
compiler.tllbc git-tracked bootstrap seed
▼
TLL Compiler (pure TLL) 152 fn · 3867 const · 18463 instructions
▼
your.tll → your.tllbc bytecode runs on native VM
// Syntax

Write TLL. Be TLL.

Lexical scoping, first-class functions, closures, exceptions, modules. Familiar C-like syntax — semicolons optional.

hello.tll
closure.tll
server.tll
// a first program fn main() { io.println("Hello, TLL OS!") } main()
fn makeCounter() { let n = 0 fn inc() { n = n + 1 return n } return inc } let c = makeCounter() io.println(c()) // 1 io.println(c()) // 2 io.println(c()) // 3
fn handle(req: map) -> map { if req.path == "/healthz" { return { status: 200, body: "ok", contentType: "text/plain" } } return { status: 404, body: "not found", contentType: "text/plain" } } fn main() { http.serve("0.0.0.0:28091", handle) }
// Frozen contract

46 opcodes. One bytecode schema.

The closure model is encoded directly in the instruction set — not a library layer on top.

42
OP_CLOSURE
Create closure with captured environment
43
OP_GET_UPVALUE
Read captured upvalue from box
44
OP_SET_UPVALUE
Write captured upvalue — shared box
45
OP_BOX_LOCAL
Box local for escaping closure capture
21
OP_CALL
Direct fnIdx or indirect register dispatch
37
OP_THROW
Unwind stack, run finally, jump to catch

Start building TLL.

Apache 2.0 · Self-hosting · No JS · Deterministic · 46 opcodes frozen