The systems language that writes less so it can prove more.
With is native by default, exactly as safe as Rust, and allergic to ceremony. Every character the compiler can infer is a character you never type.
macOS · Linux · Windows. One binary. No system LLVM required.Native control. Rust-level safety. C-level reach.
With pays compiler complexity so you don't pay it in ceremony — the guardrails stay, the boilerplate goes.
// the body makes the return type obvious, so it's inferred. fn shout(s: str): s ++ "!" // main returns i32 to the OS — no trailing 0 needed. fn main: print(shout("Hello, World"))
No ceremony
If the compiler can infer, import, bind, prove, or generate it, you don't spell it out. No Ok(()), no let _ =, no trailing return. Every unnecessary character is a compiler failure.
Exactly as safe as Rust
Single ownership, consuming destructors, generational references — the best of Vale. A resource lives in its scope and is released when the scope ends. Leaking is a defect, not a convenience.
C is first-class
Point c_import at a header and call the library — no shim, no bindings, no becoming the build system. Raw C stays explicit; modeled C becomes humane. The migrator brings whole libraries across.
From an empty folder to a native window — in three commands.
With models C libraries for you. Fetch raylib, write a little math, and run a real, hardware-accelerated graphics program. No bindings, no CMake, no glue.
with init spiral
Scaffold a project: a manifest and src/main.w. Nothing else to configure.
with get c.raylib
Fetch raylib, read its headers, model the C API, and link it — you get typed functions to call.
with run
Compile to native and launch. A window opens with a living, colored spiral.
$ with init spiral && cd spiral created with.toml, src/main.w $ with get c.raylib ✓ fetched raylib · modeled the C API · linked # write the spiral into src/main.w → $ with check src/main.w ok $ with run ✓ native build · a window opens, spinning
use c_import("raylib.h") extern fn sin(x: f64) -> f64 extern fn cos(x: f64) -> f64 fn main: unsafe { InitWindow(900, 600, c"with · spiral".ptr) } SetTargetFPS(60) var t = 1.25 while not WindowShouldClose(): BeginDrawing() ClearBackground(Color { r: 14, g: 16, b: 26, a: 255 }) for i in 0..180: let p = i as f64 / 180.0 let angle = p * 18.85 + t * 0.8 let radius = 28.0 + p * 250.0 + sin(t * 1.4 + p * 6.0) * 18.0 let x = 450.0 + cos(angle) * radius let y = 300.0 + sin(angle) * radius let hue = (p * 360.0 + t * 50.0) as f32 DrawCircle(x as i32, y as i32, (4.0 + p * 4.0) as f32, ColorFromHSV(hue, 0.86 as f32, 1.0 as f32)) EndDrawing() t = t + 0.02 CloseWindow()
WIPE: SURVIVAL
One arena. One hit. One more try.
A twin-stick survival game built in With. Dodge a relentless swarm, carve through luminous wireframes, and light up a reactive grid — all to a bass-led ambient house soundtrack.
Explore WIPE on GitHubKeep moving. Keep firing.
Automatic fire, one-hit kills, and immediate retries. Move and aim with keyboard and mouse or a twin-stick controller.
Arena meets atmosphere.
Gaussian bloom, directional sparks, and a reactive grid turn every close call into a burst of light.
Go from pixels to source.
Explore the With simulation, rendering, shaders, and audio — then build and play it yourself.
Small on the page. Strict underneath.
Every sample below compiles and runs on the current release.
// no `-> str`: the body makes the type obvious. fn shout(s: str): s ++ "!" fn main: for name in ["ergonomic", "native", "safe"]: print(shout(name))
fn main: for i in 1..101: match (i % 3, i % 5): (0, 0) => print("FizzBuzz") (0, _) => print("Fizz") (_, 0) => print("Buzz") _ => print(i.to_string())
use c_import("math.h") fn main: let r = sqrt(2.0) // C's sqrt, called directly print(f"sqrt(2) = {r}\n")
fn main: var xs: Vec[i32] = Vec.new() xs.push(2); xs.push(3); xs.push(4) var total = 0 for i in 0..xs.len() as i32: total = total + xs[i] // xs is freed here — its scope ends. No free() to forget.
One command. One binary.
The installer downloads a single self-contained compiler for your platform. The static LLVM toolchain is embedded — no system LLVM, no extra setup.
$ curl -fsSL https://withlang.org/installer/install.sh | sh
> irm https://withlang.org/installer/install.ps1 | iex
> curl.exe -L -o install.cmd https://withlang.org/installer/install.cmd > install.cmd
Prefer to read first? Every installer is plain text — open install.sh, install.ps1, or install.cmd before you run it.
After it runs
- The binary lands in
~/.local/bin(or%USERPROFILE%\.local\binon Windows). Add it to yourPATHif it isn't already. - Choose another location with
WITH_INSTALL_DIR, or pin a version withWITH_VERSION. - Then run your first program:
$ with -e 'print("hello!")'
hello!Building from source or cross-compiling instead? See the README and releases.
Built by one engineer, in the open.
Eric Hartford
Eric created With and writes its self-hosting compiler — the compiler that builds With is itself written in With. He is Chief Scientist at Lazarus AI and Founder & CEO of Quixi AI, and the creator of the Dolphin and Samantha open-weight model families, which have reached millions of downloads.
Before the current generation of AI work — dataset curation, full-parameter fine-tuning, alignment, evaluation, quantization, and deployment — he was a full-stack software engineer at Microsoft, AWS, eBay, and other technology companies. That span, from the model layer down to the systems layer, is where With comes from: a conviction that low-level control and human ergonomics are not a trade-off.
Write less. Prove more.
Install the compiler, point c_import at a header, and ship native code without the ceremony.