About Jda: A Self-Hosted, High-Performance Systems Programming Language

What is Jda?

Jda is an open-source systems programming language built entirely from scratch. It features a self-hosted compiler written in Jda itself, which was bootstrapped from raw x86-64 assembly. Notably, Jda has no dependencies on C, C++, Rust, LLVM, or any other external compiler toolchain. It is free software released under the MIT License.

On May 17, 2026, Jda officially announced itself to the wider developer community. Although the language reached its 1.0.0 milestone recently, this announcement marks the first broad invitation for developers to explore the ecosystem and contribute to its future. The project actively seeks community feedback, whether for bug reporting, feature suggestions, or general user experiences.

Benefits

Jda was designed with five core principles in mind:

1. Self-Sufficiency: The entire toolchain is written in Jda, eliminating the need for external compilers or foreign runtimes.
2. Performance: Jda aims to outperform C on 3 out of 5 benchmarks and compiles 33 times faster than Rust. It utilizes an SSA-based Intermediate Representation (IR) featuring constant folding, Dead Code Elimination (DCE), tail call optimization, register allocation, and peephole optimizations.
3. Simplicity: The language prioritizes clarity with a small, readable syntax. It employs structs, traits, and impl blocks (avoiding complex class hierarchies), explicit types, and straightforward control flow.
4. Batteries Included: The standard library comprises 114 packages covering networking, cryptography, data structures, file I/O, HTTP, JSON, compression, testing, machine learning, and more.
5. Great Tooling: The ecosystem includes a formatter, language server, documentation generator, test runner, benchmarker, fuzzer, race detector, REPL, package manager, version manager, and a VS Code extension.

Use Cases

Jda offers a robust set of features suitable for systems programming:

• Core Language: Functions, structs, arrays, pointers, references, if/else, loops, for-in loops, const, enums, generics, const generics, closures, pattern matching, defer, and inline assembly.
• Type System: Supports i64, i32, i8, f64, bool, and &T references. It includes generics (fn foo()) and const generics (fn foo()).
• Object-Oriented Programming: Utilizes a Rust-style approach with structs, traits, and impl blocks, supporting method dispatch and operator overloading, along with derive macros.
• Concurrency: Provides spawn/channels, green threads (J-Threads), deadlock detection, atomic operations, and race detection.
• Error Handling: Features a Result type, a ? operator for error propagation, defer for cleanup, and panic for unrecoverable errors.

As of March 1, 2026, Jda has achieved self-hosting convergence. The compiler compiles itself and produces a byte-identical binary, reaching a fixed point in the bootstrap process.

• Standard Library: 114 packages available.
• Testing: 361 conformance tests, all passing.
• Platform Support: Native support on Linux; Docker-based support on macOS and Windows.
• Installers: Native installers are available for Windows (.exe), macOS (.pkg), Ubuntu (.deb), and Fedora (.rpm).

Additional Information

Jda's development began with a minimal assembler (jda0) written in x86-64 assembly. This assembler was used to build a simple compiler, which in turn built a more capable compiler, iterating through stages where each new version was written in the language produced by the previous stage.

Today, the Jda compiler compiles itself. The source code (jda1.jda) is a single file of approximately 22,000 lines that implements the full compilation pipeline, including the lexer, parser, SSA-based IR, optimizations, register allocation, and direct x86-64 machine code emission. The output is a statically linked ELF binary with no libc dependency; system calls go directly to the kernel.

Jda is free and open-source software. The project welcomes contributions from the community to help shape its future. Developers are encouraged to explore the source code, report issues, and participate in discussions to assist in the language's continued development.