Open Source • MIT License

A programming language built from scratch

Jda is a fast, self-hosted systems language. No C. No Rust. No LLVM. Bootstrapped from raw x86-64 assembly, all the way up. The compiler compiles itself.

Download Jda 1.0.0 Get Started

117 stdlib packages • 388 tests passing • 33x faster compile than Rust

// 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
    let line_num = 1
    for i in range(str_len(buf)) {
        if substr_match(buf, i, pattern, pat_len) {
            print_match(path, line_num, buf, i)
            matches += 1
        }
        if byte_at(buf, i) == 10 { line_num += 1 }
    }
    ret matches
}

Compiles to a ~1 MB static binary with zero external dependencies.

Performance

Benchmarked against C (gcc -O2), Rust, Go, Python, and Ruby. Same Docker environment, best of 3 runs.

Runtime

BenchmarkCJdaRustGoPython
sieve 1M27ms24ms31ms32ms416ms
sum 100M57ms49ms30ms80ms8,183ms
json parse 50K32ms31ms33ms90ms159ms
matmul 200x20030ms37ms32ms40ms2,265ms
fib(35)40ms148ms62ms126ms2,826ms

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

Compile Time

BenchmarkC (gcc)JdaRustGo
sieve 1M479ms45ms1,579ms658ms
sum 100M434ms40ms1,209ms678ms
json parse 50K510ms48ms1,726ms789ms
matmul 200x200478ms42ms1,628ms695ms
fib(35)495ms42ms1,269ms746ms

43ms average. 11x faster than gcc, 33x faster than Rust, 16x faster than Go.

Full benchmark analysis →
JDA Forge

JDA Forge

A full-stack web framework built for productivity and performance.

Forge provides everything you need to build modern web applications. Built entirely in Jda, it offers a Rails-style development experience with zero external dependencies.

  • Routing & Controllers • Rails-style DSL
  • ORM & Migrations • Query builder with associations
  • Templates • Compiled views with zero runtime overhead
  • Built-in Tools • Mailer, WebSocket, Background Jobs
Explore Documentation →
import "forge"

fn handle_root(ctx: i64) {
    ctx_html(ctx, 200, "<h1>Hello from Forge</h1>")
}

fn main() {
    let app = app_new()
    app_get(app, "/", fn_addr(handle_root))
    app_listen(app, 8080)
}

Why Jda?

Self-Hosted from Assembly

The Jda compiler is written in Jda. No external C, C++, Rust, or LLVM dependencies. Bootstrapped from raw x86-64 assembly — the compiler compiles itself and produces a byte-identical binary.

Beats C on 3 of 5 Benchmarks

SSA-based IR with constant folding, dead code elimination, register allocation, tail call optimization, and peephole optimizations. Compiles in 42ms average — 33x faster than Rust.

Lightweight Concurrency

Green threads (J-Threads), typed channels, atomics, and built-in deadlock detection. Goroutine-style concurrency without the Go runtime.

ML / AI Built-In

Tensors, autograd, neural networks, and transformer architectures in the standard library. GPU acceleration via AVX-512, PTX (NVIDIA), and ROCm (AMD).

117 Stdlib Packages

Networking, crypto, JSON, HTTP client/server, archives (tar, zip, gzip), regex, data structures, testing, benchmarking, and more. Everything to build real applications.

Complete Tooling

Formatter, LSP server, doc generator, test runner, benchmarker, fuzzer, race detector, REPL, package manager, and version manager.

IDE Support

VS Code extension and JetBrains plugin with syntax highlighting, LSP integration, hover docs, diagnostics, auto-completion, bracket matching, code folding, and snippets.

Struct + Trait + Impl

Rust-style OOP model. Traits, impl blocks, derive macros (Debug, Eq, Clone, Hash, Ord), generics, const generics, and closures.

Open Source (MIT)

Jda is free and open source software. Use it, modify it, contribute to it. The entire language, compiler, stdlib, and tooling are MIT-licensed on GitHub.

Built with Jda

Real applications — not toy demos. Each compiles to a <1.1 MB static binary with zero external dependencies.

jda-grep

561 lines • ~1 MB binary

A ripgrep-style text search tool. Pattern matching, case-insensitive search, line numbers, match count, invert match, multi-file search, stdin piping, and ANSI color output.

./jda-grep -ni "TODO" src/*.jda

jda-httpd

450 lines • ~1 MB binary

A static file HTTP server. Serves files on port 8080 using raw TCP syscalls. Handles MIME types, directory listing, and concurrent connections.

./jda-httpd --port 8080 --root ./public

jda-ml-demo

486 lines • ~1 MB binary • 37x faster than Python

Neural network training benchmark — 37x faster than Python. XOR classification, sine approximation (35x faster), and 64x64 matrix multiply (25x faster). Identical algorithms, no NumPy on either side.

./jda-ml-demo

Step-by-step guides: Build a CLI Tool • Build an HTTP Server • Train a Neural Network

Code Examples

Hello World

fn main() -> i64 {
    print("Hello, world!\n")
    ret 0
}

Structs & Traits

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
    }
}

Concurrency

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)
    // receive until closed
    ret 0
}

HTTP Server

import "httpserver"

fn handler(req: &Request) {
    http_respond(req, 200,
        "Hello from Jda!")
}

fn main() -> i64 {
    let srv = http_server_new(8080)
    http_server_route(srv, "/", handler)
    http_server_start(srv)
    ret 0
}

Neural Network

import "tensor"
import "autograd"
import "nn"

fn main() -> i64 {
    let w = tensor_randn(784, 128)
    let x = tensor_randn(1, 784)
    let y = nn_relu(tensor_matmul(x, w))
    backward(y)
    ret 0
}

Generics & Derive

derive(Debug, Eq, Clone)
struct Pair<T> {
    first: T
    second: T
}

fn swap<T>(p: &Pair<T>) {
    let tmp = p.first
    p.first = p.second
    p.second = tmp
}
More examples in the docs →

Latest News

Jda v1.1.0 — macOS Native Backend + 6.6× LZ77 Win Over C

Jda v1.1.0 is out. This release ships the macOS native compilation backend and a set of compiler optimizations that push Jda ahead of C, Rust, and Go on two of five real-world benchmarks — while running via Rosetta 2 x86-64 on Apple Silicon.

macOS Native Backend

jda build --macos now emits x86-64 Mach-O binaries that run directly on macOS after a codesign -s -. Syscall numbers are translated automatically from Linux to macOS BSD at JIR emit time — user programs don’t change.

Announcing JDA Forge: A Full-Stack Web Framework for Jda

Today we are proud to announce the release of JDA Forge v1.0.0, a comprehensive full-stack web framework designed for the Jda programming language.

Forge brings the productivity of modern rapid-application-development frameworks like Ruby on Rails to the Jda ecosystem. It provides a highly integrated suite of tools that allow developers to build secure, scalable, and high-performance web applications with ease.

Key Features

  • Rails-style DSL: Intuitive routing, controllers, and resource management.
  • Powerful ORM: A robust query builder with support for associations (belongs_to, has_many, has_many_through), polymorphic relationships, and callbacks.
  • ERB-style Templates: Fast, compiled views with zero runtime overhead.
  • Built-in Security: Secure password hashing (bcrypt), CSRF protection, SQL injection prevention, and more.
  • Comprehensive Tooling: Background jobs with retries, a robust mailer system, WebSockets with ActionCable-style channels, and an asset pipeline with production fingerprinting.
  • CLI Generators: Quickly scaffold entire resources, models, and migrations.

Built for Speed

Because JDA Forge is built on top of the Jda programming language, it inherits Jda’s extreme performance. The entire framework compiles down to efficient machine code, making it one of the fastest full-stack options available.

Announcing Jda: A Systems Language Built from Scratch

Today, we are excited to officially announce the Jda Programming Language.

Jda is a systems programming language designed with a radical philosophy: zero external dependencies. Unlike most modern languages that rely on C libraries or the LLVM infrastructure, Jda was bootstrapped from raw x86-64 assembly and built its way up to a fully self-hosted compiler.

Why Jda?

In an era of increasingly complex software stacks, Jda aims for transparency and extreme performance through simplicity.

More news →