I built Arden to optimize one thing: feedback loop speed

TheRemyyy — Wed, 15 Apr 2026 20:39:07 +0000

Most language posts sell syntax.
I care more about this: edit code -> get signal fast.

Arden is a native systems language built around that loop:

native output via LLVM
strict static checks (types, borrowing, effects)
one CLI that handles build/run/check/fmt/lint/fix/test/bench/profile/bindgen/lsp

Why this is different

I didn’t want a “compiler demo” that only parses files.

Arden has a full project pipeline with:

project graph rewrite
import + semantic validation
object codegen + linker integration
cache-aware rebuild path
phase timings (arden build --timings) so you can see where time goes

Example loop on Windows

From a tiny project run:

cargo build --release: ~2.03s
arden build --timings: ~0.123s total

Example loop on Linux

On my Linux run with the same tiny shape:

cargo build --release: ~0.13s
arden build --timings: ~0.033s total

These are machine-specific numbers, not universal claims.
The point is the workflow: Arden is designed to make the compile-check-fix loop short and inspectable.

Bigger benchmark snapshot (repo harness)

The repo includes a reproducible harness comparing Arden / Rust / Go on shared workloads.

Latest hot compile snapshot (compile_project_starter_graph) on my benchmark machine:

Arden: 0.0075s mean
Rust: 0.1636s mean
Go: 0.0437s mean

Again: benchmark context matters. I publish commands and outputs so people can rerun and challenge numbers.

Language model in one sentence

Arden tries to combine:

native performance path
strict correctness boundaries
practical day-to-day tooling in one place

If that sounds interesting, I’d love feedback from people who care about compilers, DX, and build systems.

Repo: https://github.com/TheRemyyy/arden-lang
Docs: https://www.arden-lang.dev/docs/overview

I Built a Programming Language with an LLVM Backend at 15. Here's How It Actually Works

TheRemyyy — Sun, 01 Mar 2026 15:19:14 +0000

I wanted something with Java's clean syntax, Rust's memory safety, and C's raw speed. Nothing out there gave me all three so I just built it myself.

That's Arden. A compiled, statically typed language that compiles to native machine code through LLVM. Not an interpreter, not a transpiler. A real compiler, written in Rust, finished in about a month.

Here's how the whole thing works and what actually hurt building it.

The Pipeline

Every compiler is just a chain of transformations. You keep transforming source code until you get something the machine can run.

Source (.arden) → Lexer → Parser → AST → Type Checker → Borrow Checker → LLVM Codegen → Native Binary

Each stage does one thing and hands off to the next.

Lexer

Reads raw text, turns it into tokens. KEYWORD_IF, INTEGER_LITERAL, LBRACE. Nothing clever, just recognition. Smallest stage, but if you get it wrong everything downstream breaks in confusing ways.

Parser and AST

Takes the tokens and builds an Abstract Syntax Tree. A tree representing the actual structure of the program. A function call becomes a node with children for each argument. An if statement becomes a node with a condition and branches.

I wrote it as a hand-rolled recursive descent parser instead of using a generator. More work but full control over error messages, which matters when someone actually tries to use the language.

function add(a: Integer, b: Integer): Integer {
    return a + b;
}

That becomes a function node with the name, typed parameters, return type, and a body with a return statement wrapping a binary add expression.

Type Checker

The biggest file in the compiler, around 2200 lines. Walks the AST and verifies every expression has a valid type. Infers types where it can, errors where things don't line up. Generics and interface checking both live here.

Borrow Checker

This was the hardest part for me honestly. Arden has Rust-inspired ownership and borrowing and getting the memory safety rules right, making sure everything allocates and deallocates correctly, tracking what's borrowed where, that took the most brain power out of everything.

The syntax ended up cleaner than Rust though:

function update(borrow mut player: Player): None {
    player.score = player.score + 1;
    return None;
}

All enforced at compile time, no runtime cost.

LLVM Codegen

LLVM is the backend used by Clang, Rust, Swift and others. You emit an intermediate representation and it handles optimization and compilation to native code.

The codegen is around 7500 lines. Every language feature needs its own translation logic. Classes become structs with vtables for dynamic dispatch. Generics use monomorphization. Async/await transforms into a state machine. String interpolation like "Hello {name}" lowers into runtime format calls.

The namespace and class system gave me real problems here. The way I had globals set up, the import resolution kept grabbing the wrong things. I had to rewrite and test that part several times before it actually worked correctly. Not fun but eventually it did.

The Moment I Almost Gave Up

At some point I ran a benchmark and Arden was doing arithmetic about 2 seconds slower than Rust and C. I thought the performance was just fundamentally broken.

Turned out I was benchmarking a debug build. No optimizations, no inlining, nothing. Once I added the proper optimization flags the performance ended up very close to Rust and C. That was a relief.

What Arden Looks Like

import std.io.*;

class Calculator {
    mut lastResult: Float;

    constructor() {
        this.lastResult = 0.0;
    }

    function add(a: Float, b: Float): Float {
        result: Float = a + b;
        this.lastResult = result;
        return result;
    }
}

function main(): None {
    calc: Calculator = Calculator();
    result: Float = calc.add(3.0, 4.0);
    println("Result: {result}");
    return None;
}

Classes, generics, interfaces, pattern matching, async/await, string interpolation, file I/O. All compiling to a native binary with no runtime overhead.

What I Actually Learned

You can not fake understanding when building a compiler. Every shortcut in the type checker causes wrong behavior three stages later. Every ambiguity in your language design shows up as a bug eventually.

The thing that helped most was keeping each stage focused on exactly one job. That pattern shows up everywhere once you start seeing it.

If you want to really understand how programming languages work, build one. Even something tiny. The concepts transfer to everything else.

Source on GitHub at github.com/TheRemyyy/arden-lang. Questions about any specific part, drop them in the comments.

DEV Community: TheRemyyy