Test suite green on all platforms

A systems language for
explicit state and
explicit failure.

"The world is not exceptional; it is a stream of explicit states."

FreedomLang compiles to native x86-64 with no libc, no runtime, no garbage collector. Small binaries you can audit. Deterministic semantics you can trust.

Get Access See the Code

✓ Linux ELF

✓ macOS Mach-O

✓ Windows PE

■

No Libc

Direct syscalls only. No hidden dependencies, no supply chain risk, no libc version conflicts.

▲

Fail-Fast

Bugs terminate immediately via fall. No silent partial failures. No exception soup.

●

Chaos Tags

World state modeled as data. File missing? Network timeout? It's a tagged value, not an exception.

◊

Small Binaries

Kilobytes, not megabytes. The entire binary is inspectable. No opaque runtime blobs.

★

TCP Networking

Built-in socket operations. Write servers and clients without external dependencies.

♦

UTF-8 & Bytes

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

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

A TCP echo server in FreedomLang. Direct syscalls, explicit error handling, zero dependencies.

echo-server.flx x86-64

// TCP Echo Server - direct syscalls, no libc
credits: <f/net> <f/bytes> <f/operators>;

let port = 8080;
let server = tcp_listen[port];

print "Listening on port " + int_to_string[port];

loop (
  let client = tcp_accept[server]
    with chaos {
      SocketError(e) => ( print "accept failed"; continue; ),
    };

  let data = tcp_recv[client, 1024]
    with chaos {
      Closed(_) => ( tcp_close[client]; continue; ),
    };

  // Echo back what we received
  tcp_send[client, data];
  tcp_close[client];
)

chaos-example.flx world state as data

// Chaos tags make world conditions explicit
credits: <f/files>;

op load_config [path] has chaos { Missing, Unreadable } (
  if not exists[path] ( => @Missing; )
  let content = read[path]
    with chaos { PermissionDenied(_) => ( => @Unreadable; ) };
  => content;
)

let cfg = load_config["/etc/myapp/config"]
  with chaos {
    Missing => "defaults",
    Unreadable => ( fall "Cannot read config"; ),
  };

print "Config: " + cfg;

Use Cases

Built for the critical edges of your security pipeline.

■ Security Scanners & Agents

Host posture checks
File integrity verification
Config compliance agents
Simple daemons with clear failure modes

▲ DevSecOps Automation

CI/CD security gates
Pre-deploy validation
Policy-as-code executors
Replace fragile shell scripts

● Policy Engines

Rule evaluation in minimal runtime
Sandboxed policy execution
Clear process boundaries
Auditable decision logic

◊ High-Integrity Tools

Internal security team utilities
Bespoke client tools
Auditabile end-to-end
Inspectable machine code

Status

✓ End-to-end compiler (source → native binary)
✓ Linux ELF, macOS Mach-O, Windows PE
✓ Arrays, objects, strings, operators
✓ Chaos tags and world state modeling
✓ TCP networking (connect, listen, accept, send, recv)

✓ Bytes handling and UTF-8 conversion
✓ Fail-fast semantics (fall, assert, expect_eq)
✓ Concurrency primitives (weave/wait)
● FFI and integration points (in progress)
● Editor tooling (in progress)

A systems language for explicit state and explicit failure.