Now open source 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. Fast to compile. Unusually predictable for both humans and language models.

Rust proved the destination is right. Ingle shortens the road — with structured concurrency, no function coloring, and verification built into the language.

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]}

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 and an M:N scheduler. 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.

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-lang && 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