v0.1 · QBE-backed · self-hosting underway

Down to
the marrow.

Marrow is a small, explicit systems language that compiles straight to native code through QBE. No garbage collector. No hidden runtime. No implicit allocations — if your program allocates, it's because you told it to.

Get startedView source
hello.mw
@import("std")

@export fn main() {
    println("Hello from Marrow !");
}
terminal
$ marrow hello.mw
Compilation successful! Executable created at: hello
$ ./hello
Hello from Marrow !
Built for control

What you write is what runs.

No hidden runtime

No garbage collector, no implicit allocations, no hidden control flow. Every allocation traces back to a function you called.

C-friendly by design

@extern declares a foreign function and calls it directly — it's how the entire standard library is built on top of libc.

QBE-backed codegen

A small compiler emits textual QBE IL, then shells out to qbe and your system C compiler for real, native binaries.

Byte-explicit memory

Pointer arithmetic moves in raw bytes, not scaled magic. An arena allocator ships in std for bulk, bump-style allocation.

From source to silicon

A short, readable compiler.

Five plain stages, each its own module — no macro-expansion phase, no borrow checker, no separate type-checking pass. Types resolve as code is generated.

LexerSource text → tokens
ParserTokens → AST
ImportsFlattens the module graph
CodegenAST → QBE IL
QBE + ccIL → native binary
Read about the pipeline in full →
A small, honest standard library

Seven modules. Nothing hiding underneath.

Every module is written in Marrow itself, wrapping libc through @extern. Almost every constructor that allocates has a matching function that frees.

io.mwPrinting to stdout and stderr.mem.mwRaw allocation and the arena allocator.string.mwC-strings and the growable String type.vec.mwGrowable arrays — VecPtr and VecI64.map.mwLinearMap and a DJB2 HashMap.fs.mwOpening, reading and writing files.sys.mwProcess exit, panic, assert, exec.Full referenceEvery function, signature and example →
Where things stand

Early, and honest about it.

Marrow's compiler is currently written in Rust, on its way toward self-hosting. This isn't a toy — real programs lex, parse, generate QBE IL and link today.

Working today

  • Lexer & tokenizer
  • Parser & AST
  • QBE code generation
  • CLI, argument & import handling
  • Standard library (io, mem, string, vec, map, fs, sys)

In progress

  • Full self-hosting — a Marrow compiler written in Marrow
  • Growing the standard library
  • Windows install tooling

One command away.

Installs the marrow and qbe binaries, plus the standard library, to ~/.marrow.

curl -fsSL https://raw.githubusercontent.com/zuygui/marrow/main/install.sh | sh
macOS, Windows & building from source →