Freelang – a Libc-free, direct sys/kernel call language with weird concurrency

"Model the world as data. Treat bugs as fatal." FreedomLang is a small AOT systems language that lowers source through a compact IR to libc/CRT-free native x86-64. Linux emits ELF64 machine-code bytes directly; macOS and Windows emit platform assembly. Jobs are real OS processes with filesystem-visible state. No VM, JIT, LLVM IR path, or libc/CRT in generated programs. The compiler is readable JavaScript lowering through a compact IR. Bad tags, bad field access, and impossible states terminate immediately. No exception soup pretending bugs are data. Missing files, permission failures, and network timeouts are explicit states, not hidden recovery paths. Linux emits ELF64 machine code directly. macOS emits x86-64 AT&T assembly. Windows emits x86-64 assembly for PE/COFF. Linux/macOS use fork; Windows uses CreateProcessA. FSABI inbox/outbox paths make job state inspectable. First-class byte arrays and UTF-8 string conversion. Handle binary protocols naturally. Native x86-64 without libc. Concurrency as inspectable OS processes. Generated programs are libc/CRT-free. There is no VM, JIT, or LLVM IR path. Linux writes ELF64 machine code directly, macOS emits AT&T assembly, and Windows emits assembly linked into PE/COFF. Process-per-job concurrency is heavier than goroutines or async tasks. The point is a smaller story: job state you can inspect on disk, failure boundaries the OS understands, and execution that humans and AI agents can reason about. These are the backend paths in the current compiler source. There is no bytecode VM: Linux emits x86-64 machine-code bytes directly, while macOS and Windows emit platform assembly for native linkers. The cost is that process-per-job concurrency is heavier than goroutines or green threads. The benefit is containment and auditability: job boundaries are OS process boundaries, and values cross those boundaries through files you can inspect. FreedomLang is early, but its core claims are implementation-backed. The table separates what is solid today from surfaces that are still being hardened. FreedomLang is not a direct descendant of one language. It combines older ideas in a small AOT compiler: native-output systems languages, Unix job control, tagged result values, object-shaped calls, and agent-readable implementation practice. FreedomLang ├─ C / Zig / Go family │ ├─ AOT compilation to native artifacts │ ├─ operational tools as a serious target │ └─ explicit release binaries instead of a VM or JIT ├─ Unix process model and shell job control │ ├─ fork blocks │ ├─ wait points │ └─ filesystem-visible job inbox/outbox state through FSABI ├─ ML / Rust Result / tagged-union thinking │ ├─ external world states represented as explicit values │ └─ recoverable outcomes separated from bugs ├─ Erlang-style fault-boundary intuition │ ├─ jobs as failure boundaries │ └─ fatal invariants handled by containment, not local exceptions ├─ JavaScript/object-record ergonomics │ ├─ object-shaped calls │ └─ field-oriented runtime shapes ├─ Operator-rich languages │ ├─ custom positional and object-shaped operators │ └─ infix and value-shape overloads for domain notation └─ Agent-readable implementation practice ├─ compiler distributed as Node.js-readable JavaScript source ├─ behavior tests as executable claims └─ explicit effects, waits, and fatal paths for debugging World State vs Bugs FreedomLang makes a sharp distinction between world conditions (things that can happen) and bugs (things that shouldn't). A missing file isn't an error—it's a world state you handle explicitly. An out-of-bounds access isn't a world state—it's a bug that terminates execution. This separation keeps your logic deterministic while acknowledging that the world outside your program is inherently chaotic. These examples compile, link, and run on macOS from the current repository. credits: ; op describe {name, role} ( print "user: " + name + " (" + role + ")"; ) describe {role: "admin", name: "alice"}; let result value; => 0; ) )& print result; examples/loopback-echo.flx loopback TCP credits: ; let listener = tcp_listen_auto[4] with chaos { _ => -1 }; let port = listener\port; let client = tcp_connect["127.0.0.1", port] with chaos { Refused(_, _) => retry 50 _ => -4 }; let conn = tcp_accept[listener\sock] with chaos { _ => -2 }; let msg = %[1, 2, 3, 4]; let sent = tcp_send[client, msg] with chaos { _ => -5 }; let data = tcp_recv[conn\sock, 4] with chaos { Closed(_) => %[] _ => %[] }; let echoed = tcp_send[conn\sock, data] with chaos { _ => -3 }; let reply = tcp_recv[client, 4] with chaos { Closed(_) => %[] _ => %[] }; tcp_close[client] with chaos { _ => 0 }; tcp_close[conn\sock] with chaos { _ => 0 }; tcp_close[listener\sock] with chaos { _ => 0 }; print sent; print echoed; print _intrinsic_bytes_len[reply]; Pain Points FreedomLang is aimed at places where hidden failure behavior, hidden dependencies, and hidden concurrency make small tools

Freelang – a Libc-free, direct sys/kernel call language with weird concurrency

Key takeaways

More in computer-science