No libc. No VM. No hidden jobs.

Native x86-64.
OS-process jobs.
No libc.

"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.

View on GitHub See the Code
✓ Linux ELF, no libc
✓ macOS -nostdlib
✓ Windows PE/COFF, no CRT
No more magic →
■

No Runtime Maze

No VM, JIT, LLVM IR path, or libc/CRT in generated programs. The compiler is readable JavaScript lowering through a compact IR.

▲

Bugs Die There

Bad tags, bad field access, and impossible states terminate immediately. No exception soup pretending bugs are data.

●

The World Is Data

Missing files, permission failures, and network timeouts are explicit states, not hidden recovery paths.

◊

Native Artifacts

Linux emits ELF64 machine code directly. macOS emits x86-64 AT&T assembly. Windows emits x86-64 assembly for PE/COFF.

★

Actual Processes

Linux/macOS use fork; Windows uses CreateProcessA. FSABI inbox/outbox paths make job state inspectable.

♦

UTF-8 & Bytes

First-class byte arrays and UTF-8 string conversion. Handle binary protocols naturally.

Byline

Native x86-64 without libc. Concurrency as inspectable OS processes.

The Weird Parts

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.

The Tradeoff

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.

Backends and Process Model

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.

Target Code output Process backend Concurrency state
Linux x86-64 Direct ELF64 with raw x86-64 machine code and kernel syscalls. fork syscall; wait4/waitpid for joins. FSABI tree under /tmp/freelang/jobs.
macOS x86-64 AT&T x86-64 assembly linked as Mach-O with -nostdlib. Darwin fork syscall; wait4 for joins. FSABI tree under /tmp/freelang/jobs.
Windows x86-64 x86-64 assembly linked into PE/COFF without CRT default. CreateProcessA self re-exec with worker flags; WaitForSingleObject for joins. FSABI tree under %TEMP%\freelang\jobs.

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.

Feature Domains

FreedomLang is early, but its core claims are implementation-backed. The table separates what is solid today from surfaces that are still being hardened.

Domain Status What exists now Honest note
Native compiler pipeline ✅ covered Parser, IR lowering, and x86-64 backends live in the repo. No serious optimizer yet; the compiler is pre-1.0.
Node-readable compiler ✅ covered The compiler is JavaScript source run with Node.js, not a sealed project-specific compiler binary. Node.js is still a binary dependency; the claim is about the FreedomLang compiler distribution.
Native targets ✅ covered Linux ELF64 machine code, macOS Mach-O via AT&T assembly, and Windows PE/COFF via native x86-64 assembly. Windows is native assembly for the Microsoft ABI, not a VM or transpiler path.
Small binaries, no libc/CRT default 🟡 bounded Generated programs are libc/CRT-free across the supported backend paths and emit helper code only as needed. Smaller dependency surface is not a security proof; OS APIs and runtime helpers still matter.
Bounds, shape, and fast-fail checks ✅ covered Array/object access checks, fatal invalid-state paths, fall, assert, and expect_eq. Runtime checking, not static memory safety or formal verification.
Custom operators ✅ covered Positional, object-shaped, infix, shaped infix, and value-shape operator forms. The syntax is unusual and will need careful examples and restraint.
FSABI concurrency ✅ covered Fork blocks, handles, wait, blocking fork sugar, job directories, and inbox/outbox paths. Linux/macOS use fork; Windows uses CreateProcessA. Favors explicit process/job semantics over lightweight in-process concurrency.
Chaos/world-state modeling 🟡 hardening with chaos and chaos tags model external outcomes as explicit data. Strongest on macOS today; Linux and Windows parity are still moving.
Heap and GC 🟡 hardening Heap allocation exists across targets; macOS has the strongest generated GC path today. No-heap/no-GC mode is an aspiration, not a stable flag yet.
AI-agent ergonomics 🟡 thesis Small compiler, explicit jobs, behavior tests, and visible failure boundaries. Promising design direction, not a benchmarked claim.

Language Genealogy

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.

World State
File missing, permission denied, timeout, bad input
↓ modeled as data via has chaos / with chaos
Bug
Out-of-bounds, invalid tag, impossible state
↓ terminates via fall

Real Working Code

These examples compile, link, and run on macOS from the current repository.

examples/auditable-tool.flx shaped calls + fork 
credits: <f/operators>;

op describe {name, role} (
  print "user: " + name + " (" + role + ")";
)

describe {role: "admin", name: "alice"};

let result <= (
  (
    let child_value = 42;
    child_value >value;
    => 0;
  )
)&

print result;
examples/loopback-echo.flx loopback TCP 
credits: <f/net>;

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 hard to trust.

■ Critical Scripts

  • Replace fragile shell glue where failure must be explicit
  • Build small native security and automation tools
  • Keep outputs and exits behavior-testable
  • Avoid dragging in a large default runtime stack

▲ Unsafe Defaults

  • Bounds and shape checks on runtime values
  • Fatal invariants instead of silent corruption
  • World states modeled separately from bugs
  • Explicit caveats where safety is not yet proven

● Concurrency Audits

  • Fork blocks show where work starts
  • Waits show where work joins
  • FSABI directories expose inbox/outbox state
  • Process boundaries stay visible to tooling

◊ Agent-Written Code

  • Keep effects and failure boundaries in source
  • Prefer behavior tests over prose claims
  • Make runtime paths small enough to inspect
  • Treat AI-friendliness as a thesis to validate

Status

  • ✓ End-to-end compiler from source to native artifacts
  • ✓ Linux ELF, macOS Mach-O, Windows PE/COFF
  • ✓ Generated programs are libc/CRT-free
  • ✓ Arrays, objects, strings, operators
  • ✓ Native process jobs: fork on Linux/macOS, CreateProcessA on Windows
  • ✓ Fail-fast semantics through fall, assert, and expect_eq
  • ✓ Bytes handling and UTF-8 conversion
  • ✓ macOS chaos/files/TCP surfaces exercised by platform-gated tests
  • ✓ Heap support on all targets, with GC parity still hardening
  • ● Linux/Windows network and chaos parity in progress
  • ● Editor tooling (in progress)

Build tools and jobs you can inspect.

If you need a language where you can audit syntax-to-machine-code lowering and filesystem-visible process concurrency, let's talk.

Get in Touch