TL;DR

I spent the last several months building Jda — a self-hosted systems programming language bootstrapped entirely from raw x86-64 assembly. No C. No Rust. No LLVM. The compiler compiles itself, and it beats C on 3 of 5 benchmarks while compiling 33x faster than Rust.

👉 jdalang.org | GitHub

Why Build Yet Another Language?

Most "new" languages are built on top of existing infrastructure — LLVM, GCC, or at minimum a C runtime. That's totally valid, but it always felt like a shortcut to me.

I wanted to understand what a language actually is at the lowest level. So I started from scratch: raw x86-64 assembly, no external dependencies, no C library, nothing. Just me, the CPU manual, and a lot of patience.

The result is Jda — a fast, modern systems language where the compiler:

• Is written in Jda itself (self-hosted)
• Produces a ~1 MB static binary with zero external dependencies
• Compiles in an average of 43ms

Performance: Does It Actually Work?

I benchmarked Jda against C (gcc -O2), Rust, Go, and Python in the same Docker environment.

Runtime (lower is better)

Jda beats C on 3 of 5 benchmarks. 54x faster than Python on average.

Compile Time (lower is better)

11x faster than gcc, 33x faster than Rust, 16x faster than Go.

What Does Jda Look Like?

It's clean and familiar — think Go meets Rust without the boilerplate.

// A ripgrep-style file searcher in ~20 lines
import "file_io"
import "string"

fn search_file(path: &i8, pattern: &i8, pat_len: i64) -> i64 {
    let fd = file_open(path, 0)
    defer file_close(fd)
    let buf = file_read_all(fd)
    let matches = 0
    for i in range(str_len(buf)) {
        if substr_match(buf, i, pattern, pat_len) {
            print_match(path, line_num, buf, i)
            matches += 1
        }
    }
    ret matches
}

Structs and traits follow a Rust-style model:

trait Shape {
    fn area(self: &Self) -> i64
}

struct Circle { radius: i64 }

impl Shape for Circle {
    fn area(self: &Circle) -> i64 {
        ret self.radius * self.radius * 3
    }
}

And concurrency uses Go-style green threads with typed channels:

fn producer(ch: Channel<i64>) {
    for i in range(100) {
        channel_send(ch, i)
    }
    channel_close(ch)
}

fn main() -> i64 {
    let ch = channel_new<i64>()
    spawn producer(ch)
    ret 0
}

What's in the Box?

Jda ships with 117 stdlib packages including:

• Networking, HTTP client/server, WebSockets
• Crypto, JSON, regex, archives (tar/zip/gzip)
• Tensors, autograd, and neural networks — ML built right in
• GPU acceleration via AVX-512, PTX (NVIDIA), and ROCm (AMD)
• Full toolchain: formatter, LSP, doc generator, REPL, fuzzer, race detector, package manager

There's also JDA Forge — a full-stack web framework in the style of Rails, built entirely in Jda.

The Bootstrap Story

The hardest part wasn't the language features — it was the bootstrap.

Every self-hosted compiler faces the chicken-and-egg problem: you need the compiler to compile the compiler. My solution was to write the first version of the Jda compiler in raw x86-64 assembly. From there, I rewrote it in Jda itself, verified the output was byte-identical, and the bootstrap was complete.

The compiler now compiles itself. Every release is verified to produce the same binary.

Current Status

• ✅ Jda v1.0.0 released (MIT license)
• ✅ v1.1.0 shipped last week with a macOS native backend
• ✅ VS Code + JetBrains plugins with full LSP support
• ✅ 388 tests passing
• 🔜 ARM/AArch64 native backend
• 🔜 Windows support

I'd Love Your Feedback

This is still early days and I'm actively looking for feedback on:

• Language design — anything that feels off or missing?
• Stdlib gaps — what packages do you need?
• Tooling — what would make your workflow better?
• Documentation — what's unclear or missing?

Drop your thoughts in the comments — I read everything. 🙏