Native binaries Pre-1.0 MIT · Zero deps

Systems programming,
without the GC

Ingle is a statically-typed, brace-delimited language in the lineage of C, C#, and Rust. Memory-safe without a garbage collector. Runs instantly on its VM — or compiles to a standalone native binary. Unusually predictable for both humans and language models.

Executable contracts, a replayable execution tape, structured concurrency with no function coloring — and a compiler that already rebuilds itself byte-for-byte. Systems code that proves itself.

Install Ingle View source Language reference 
fn main() -> int {
    println("Hello, Ingle!")
    return 0
}
// The contract is the spec; the body must satisfy it.
fn gcd(a: int, b: int) -> int
    requires a > 0
    requires b > 0
    ensures result > 0
    ensures a % result == 0
    ensures b % result == 0
{
    var x = a, y = b
    loop {
        if y == 0 { return x }
        let t = x % y; x = y; y = t
    }
}
// Structured concurrency — no async/sync split.
nursery {
    spawn dispatch(jobs)
    spawn worker(jobs, results)
    spawn worker(jobs, results)
}
// Block exits only when every spawned task finishes.

LLM-first debugging

When a contract breaks, the tape shows exactly where

Executable requires/ensures contracts emit structured events on the execution tape — machine-readable feedback for an editor or language model, not just an abort message.

contract_violation.ig
fn half(x: int) -> int
    ensures result + result == x
{
    return x / 2  // odd x loses remainder
}

fn main() -> int {
    return half(7)
}
inglec --tape
error[postcondition_failed]:
  postcondition failed in 'half'

route: half (line 5) ← main (line 11)

{"event":"contract_violation",
 "fn":"half",
 "line":5,
 "detail":"postcondition failed…",
 "stack":[7,3]}

From script to metal

One language, one semantics, three distances from the hardware — the same program, the same contracts, the same tape at every stop.

Run it now

inglec --emit=run app.ig

The bytecode VM is the canonical semantics and the instant dev loop — no build step, contracts checked, tape on demand.

Ship a binary

inglec -o app app.ig

Emits C, compiles, links: a standalone native executable — the whole language, not a subset. The flagship GUI + HTTPS demo app compiles to a single 1.2 MB binary.

Boot bare metal (early)

inglec --emit=c --freestanding

The runtime compiles freestanding — no libc, no OS. A tiny Ingle kernel boots on QEMU (aarch64) with UART output, exception vectors, and timer interrupts. A proof of reach, not an OS.

Why Ingle

Memory-safe without a GC

Ownership, move/borrow checking, and deterministic reference counting. No pauses, no reference cycles. Shared data via rc struct and std/slotmap.

A real type system

Generics with bounds, exhaustive pattern matching, Option/Result with ?, interfaces with static and dynamic dispatch.

Structured concurrency

nursery/spawn with typed channels, running across every core. No function coloring — real stack traces, safe cancellation.

Verification built in

Executable contracts, execution tapes, and a static prover — a closed loop designed for humans and LLMs to debug against.

Two backends, one semantics

Bytecode VM as canonical reference; AST→C for native binaries. Differential tests keep them bit-for-bit identical.

Batteries included

UTF-8 strings, slices, C FFI, explicit-width numerics, stdlib in Ingle (std/http, std/map, …), plus opt-in graphics via Flare.

First-class editor support

inglec --lsp with hover, completion, rename, semantic tokens, inlay hints, signature help, and prover verdicts.

The compiler compiles itself

The full pipeline — lexer, parser, checker, codegen — is also written in Ingle and compiles itself; a self-built native compiler regenerates a byte-identical copy of itself. The C stage-0 compiler stays the reference.

LLM-first by design

Structured JSON diagnostics, a deterministic replayable tape, and the whole language in one file for a model's context: llms-full.txt.

Proof, not promises

A language that sells verification should be able to show its own. Every claim below is a gate that runs in CI on every change.

1,800+ automated checks, green on every commit

Golden tests, VM↔native differentials, doctor and LSP regressions — 431 in the core suite, 1,347 in the self-hosting gate alone.

VM ≡ native, byte for byte

Every test program runs on both backends — the bytecode VM and the compiled C — and their outputs must match exactly. Drift fails the build.

A byte-identical fixed point

The Ingle-written compiler, compiled to native by itself, regenerates its own C output byte-for-byte (N1 → N2). Self-hosting as a regression test, not a slogan.

Sanitizers and purpose-built fuzzers

ASan and TSan clean, plus three in-house fuzzers that attack memory ownership, operand-width limits, and resource linearity. CI on macOS and Linux, arm64 and x86_64.

Install

Runs on macOS and Linux (x86_64 and arm64). Requires a C17 compiler and GNU Make; the installer builds from source — no prebuilt releases yet.

Quick install (macOS & Linux)

curl -fsSL https://ingle-lang.org/install.sh | sh

Build from source

git clone https://github.com/ingle-lang/ingle
cd ingle && make && make install
make test

Installs to ~/.ingle. Run programs with inglec --emit=run file.ig or compile native binaries with inglec -o out file.ig. See the README for details.

Editor support

Extensions drive the same in-tree language server — no reimplemented frontend.

VS Code Zed

Documentation