DEV Community: JAI LALAWAT

Jda Programming Language

JAI LALAWAT — Tue, 09 Jun 2026 17:15:11 +0000

Jda is a systems language built from scratch — zero C, zero Rust, zero Python. Bootstrapped from raw x86-64 assembly, self-hosted, compiles itself. Beats C on LZ77 by 6.6×, sudoku by 1.5×, regex by 1.9× — running via Rosetta 2 x86-64 on Apple Silicon. 43ms compile time (33× faster than Rust). No GC. Green threads + channels. Tensors, autograd, AVX-512/CUDA/ROCm. 117 stdlib packages. 388 tests passing. https://jdalang.org
https://github.com/jdalang/jda-lang/

can you build a real systems language with zero external dependencies?

JAI LALAWAT — Sat, 06 Jun 2026 09:31:06 +0000

Jda started as a question: can you build a real systems language with zero external dependencies — no C, no Rust, no Python anywhere in the toolchain?

try out jda https://github.com/jdalang/jda-lang/

I built a programming language from raw assembly — and it beats C by 6.6 on LZ77

JAI LALAWAT — Thu, 04 Jun 2026 17:05:25 +0000

So I had a slightly unreasonable idea two years ago:

What if I built a programming language without depending on C, LLVM, or any existing toolchain?

The result is Jda — a high-performance systems language bootstrapped from raw x86-64 assembly. The compiler now compiles itself. No GC. No runtime. Single static binaries.

And on real benchmarks, it’s doing things I genuinely didn’t expect.

The numbers that made me double-check

I ran a 6-language benchmark suite (C, Rust, Go, Jda, Python, Ruby) on real algorithms — not microbenchmarks.

• Sudoku (500 puzzles): C 62ms, Rust 62ms, Go 66ms, Jda 41ms
• LZ77 (1 MB compress): C 1,830ms, Rust 2,185ms, Go 2,721ms, Jda 277ms

That’s 1.5× faster than C on Sudoku and 6.6× faster than C on LZ77. Running via Rosetta 2, no less — C/Rust/Go were native ARM64, Jda was x86-64 emulated.

How? Source-level optimizations the C compiler can’t easily do: MOD→AND strength reduction, hash-chain hoisting, aggressive DCE.

Compile times are kinda absurd too

33× faster compilation than Rust, 16× faster than Go. Skipping LLVM saves a lot of time.

A taste of the syntax
fn search_file(path: &i8, pattern: &i8) -> i64 { let fd = file_open(path, 0) let buf = file_read_all(fd) let matches = 0 for i in range(str_len(buf)) { if substr_match(buf, i, pattern) { matches += 1 } } ret matches }

A real ripgrep-style search tool, ~400 lines total, compiles to a 1 MB static binary with zero dependencies.

What’s in the box

• Self-hosted compiler — byte-identical fixed point reached April 2026
• 117 stdlib packages — HTTP, JSON, crypto, tensors, neural networks
• Built-in concurrency — goroutine-style green threads, no GC
• 388 conformance tests passing
• Native installers for Windows, macOS, Linux

Try it

Repo: https://www.github.com/jdalang/jda-lang

Happy to answer questions about the bootstrap process, the codegen, or why on earth I did this in the comments.

I built a zero-dependency programming language that talks directly to the Linux kernel

JAI LALAWAT — Tue, 26 May 2026 04:00:35 +0000

Most modern languages are built on top of C. They rely on libc for everything from printing a string to opening a socket.

I wanted to see if I could go deeper.

I built Jadn: a systems language with zero dependencies. It doesn't use libc. It doesn't use LLVM. It doesn't even use a linker.

Pure Syscalls
When Jadn wants to talk to the world, it talks directly to the Linux kernel. Here is how it handles a write:

1 fn print(buf: &i8, len: i64) { 2 syscall(1, 1, buf, len) // Direct syscall: write(stdout, buf, len) 3 }

The "Hardcore" Stats:

Bootstrapped from Assembly: The first compiler was written in raw x86-64 asm.
Self-Hosting: The compiler now compiles itself (fixed-point reached!).
Insane Compile Times: 42ms average. That’s 33x faster than Rust.
Tiny Static Binaries: A full grep clone or HTTP server is just 1MB and runs on any Linux machine with zero setup.

Why do this?
Because abstractions have become too heavy. By stripping away libc, I found that you can actually beat C at JSON parsing (31ms vs 32ms) and LZ77 compression (6.6x faster).
It turns out, when there's nothing between your code and the kernel, things get very fast, very quickly.
What’s the "lowest" you’ve ever gone in your stack? Assembly? Raw syscalls? Let’s talk in the comments!

👉 Try it: jdalang.org/docs/getting-started
👉 GitHub: github.com/jdalang/jda-lang
👉 Discussions: github.com/jdalang/jda-lang/discussions

33x faster than Rust: Why I stopped waiting for my compiler and built my own.

JAI LALAWAT — Tue, 26 May 2026 03:53:46 +0000

The Hook: Slow compile times are a major pain point for systems engineers. Jda's 42ms average compile time is a game-changer.

Key Points:
- Why a single-pass compiler is "fast enough" and produces 1MB static binaries.
- The "Scripting speed + Native performance" workflow.
- Built-in ML primitives: Training neural networks in a language that compiles in the blink of an eye. 👉 Try it: jdalang.org/docs/getting-started 👉 GitHub: github.com/jdalang/jda-lang 👉 Discussions: github.com/jdalang/jda-lang/discussions

How I Built a Language That Beats C on LZ77 by 6.6 — Bootstrapped from Assembly

JAI LALAWAT — Wed, 20 May 2026 04:10:22 +0000

Disclosure: This project was built with AI assistance (Claude).

I built a systems programming language called Jda from scratch — zero C, zero Rust,
zero Python anywhere in the toolchain. The compiler is bootstrapped from raw x86-64
assembly, fully self-hosted, and compiles itself to a byte-identical binary.

## The Headline Result

On LZ77 compression (1 MB of data), Jda clocks 277ms against:

C (clang -O2): 1,830ms — Jda is 6.6× faster
Rust (rustc -O): 2,185ms — Jda is 7.9× faster
Go: 2,721ms — Jda is 9.8× faster

Jda is running via Rosetta 2 x86-64 on Apple Silicon — not even native ARM64.

## Full Benchmark Table (Apple Silicon, ms, lower is better)

| Benchmark | C | Rust | Go | Jda |
|---|--:|--:|--:|--:|
| Sudoku — 500 puzzles | 62 | 62 | 66 | 41 |
| LZ77 — 1 MB compress | 1,830 | 2,185 | 2,721 | 277 |
| Regex — 8 pats × 100K | 98 | 221 | 813 | 186 |
| B-Tree — 1M ops | 282 | 297 | 318 | 586 |
| Raytracer — 800×600 | 19 | 21 | 35 | 331 |

Jda wins 3 of 5 benchmarks against native ARM64 compiled languages.

## Why Is LZ77 6.6× Faster Than C?

Two compiler optimizations do the work:

1. MOD→AND strength reduction

The LZ77 hash-chain uses a 4096-entry window. Every iteration computes:
hash % 4096
Jda's compiler rewrites this to:
hash & 4095
This eliminates every IDIV instruction from the inner loop. C, Rust, and Go
all keep the slower division form on this pattern.

2. Loop-Invariant Code Motion (LICM)

The maximum match length and first-byte filter are loop-invariant — Jda hoists
them out of the inner match scan, halving the number of iterations.

## Sudoku: 1.5× Faster Than C and Rust

The hot path is a bitmask scan over candidates. Jda's MOD→AND peephole,
copy propagation, and loop register promotion eliminate redundant work that
gcc/clang keeps in memory.

## Self-Hosting

The compiler bootstraps like this:

Assembly → jda0 → compiles jda1.jda → jda1
↓
compiles jda1.jda → jda1_sh2
↓
compiles jda1.jda → jda1_sh3
↑
byte-identical to sh2

Fixed point converged. 388 conformance tests passing.

## Compile Speed

| | gcc -O2 | rustc -O | go build | Jda |
|--|--:|--:|--:|--:|
| Average | 479ms | 1,497ms | 712ms | 43ms |

33× faster than Rust. Single-pass compiler, no linker, no intermediate files.

## What It Has

No GC — manual memory with alloc_pages
Goroutine-style green threads + channels
Tensors, autograd, neural networks
AVX-512 / CUDA / ROCm acceleration
117 stdlib packages
Full-stack web framework (Jda Forge)
VS Code + JetBrains plugins

## Try It


bash
  curl -sSf https://jdalang.org/install.sh | sh

  - GitHub: https://github.com/jdalang/jda-lang
  - Website: https://jdalang.org
  - Benchmarks: https://jdalang.org/benchmarks/complex-benchmarks/

  All benchmark source code is in the repo — six implementations of each problem
  (C, Rust, Go, Jda, Ruby, Python) side by side.

  Would love feedback on the language design, benchmark methodology, or anything
  that feels wrong or missing.

I Built a Programming Language from Scratch — No C, No LLVM, Just Raw Assembly

JAI LALAWAT — Tue, 19 May 2026 17:05:57 +0000

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)

Benchmark	C	Jda	Rust	Go	Python
sieve 1M	27ms	24ms	31ms	32ms	416ms
sum 100M	57ms	49ms	30ms	80ms	8,183ms
json parse 50K	32ms	31ms	33ms	90ms	159ms
matmul 200x200	30ms	37ms	32ms	40ms	2,265ms
fib(35)	40ms	148ms	62ms	126ms	2,826ms

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

Compile Time (lower is better)

Benchmark	C (gcc)	Jda	Rust	Go
sieve 1M	479ms	45ms	1,579ms	658ms
sum 100M	434ms	40ms	1,209ms	678ms
fib(35)	495ms	42ms	1,269ms	746ms

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?

👉 Try it: jdalang.org/docs/getting-started

👉 GitHub: github.com/jdalang/jda-lang

👉 Discussions: github.com/jdalang/jda-lang/discussions

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

I built a systems programming language from scratch — zero C, zero Rust, zero Python. Bootstrapped from raw x86-64 assembly. It beats C on 3 of 5 benchmarks. https://jdalang.org

JAI LALAWAT — Tue, 19 May 2026 06:25:42 +0000

Jda Programming Language

A self-hosted systems programming language built from scratch — zero C, zero Rust. Bootstrapped from assembly.

jdalang.org

I built a systems programming language from scratch — zero C, zero Rust, zero Python. Bootstrapped from raw x86-64 assembly. It beats C on 3 of 5 benchmarks.

JAI LALAWAT — Tue, 19 May 2026 06:25:40 +0000

How I Built a Language That Beats C on LZ77 by 6.6 — Bootstrapped from Assembly A self-hosted systems language with zero C in the toolchain, and what two compiler optimizations did to destroy the competition on compression.

JAI LALAWAT — Tue, 19 May 2026 06:20:27 +0000