Open-source project
SerenityOS/jakt avatar
SerenityOS/jakt

jakt: transpiles to C++, and error propagation is an unticked box

The Jakt Programming Language

2,992 stars236 forksC++BSD-2-Clause

At a glance

What is it?
Jakt is a memory-safe systems language from the SerenityOS group that currently compiles to C++, and the page is a checklist rather than a manual: which safety features are in, which are not, and exactly how a struct differs from a class. What it tells you plainly is that there is no way yet to propagate an error with a dedicated return type and keywords.
Who is it for?
Read Jakt as a language specification being written in public rather than a tool you would build a service in this month. What is settled is worth reading on its own: three pointer types with raw ones fenced inside unsafe blocks, no null in safe mode, reference counting by default, value semantics for structs against reference semantics for classes, explicit argument labels, and mutability carried in the receiver type.
Can I use it commercially?
Yes. BSD-2-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 86 days ago.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • SerenityOS/jakt2,992 ★ · +5
Star history
Repository2026-09-242026-11-15
SerenityOS/jakt3k3k

5 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The whole workflow is one compile command and one run command

The usage section is four sentences long and worth quoting in full because there is nothing hidden in it. It is a memory-safe systems programming language that currently transpiles to C++. The transpilation requires clang, so make sure that is installed. Then there are two commands:

code
jakt file.jakt
./build/file

One takes a source file and one runs what it produced, from a build directory relative to where you are. So the tool is not a compiler in the traditional sense, it is a code generator that hands you C++ and then a C++ compiler does the rest, and it shells out to clang every time you run it. There is no package manifest, no linker configuration and no project file anywhere in those instructions. For a language whose standard library is described as being in its infancy and whose page carries a note that it is under heavy development, that is a coherent shape: you write one file, you get one binary, and the interesting question is what the language does rather than how you ship a project with it.

Two unticked boxes, and the important one is error propagation

The readability section is a checklist of twelve features and ten are ticked. Argument labels at every call site, pattern matching, fallible and infallible optional chaining, none coalescing, defer statements, dereferencing with a dot and never an arrow, trailing closures outside the parentheses, immutability by default. Two are not. One is inferred enum scope, which means you still qualify a case by its enum type rather than writing the short name. The other is error propagation with an error-or return type and dedicated try and must keywords. For a language whose first stated goal is memory safety, having no mechanism to carry an error out of a function is the gap that matters, and the page treats it as a checkbox rather than discussing it. There is one hint about the intended direction. String literals can be implicitly converted to any type implementing a trait whose name says it throws, and in the prelude one view type does exactly that. So the language already has a place where a literal can fail to parse; it just has nowhere yet to put the failure.

Integer overflow is defined, and it is checked while your program runs

The math safety section has two rules. The first is that integer overflow, signed and unsigned both, is a runtime error. The second is that numeric values are not automatically coerced to the default integer type, so every cast has to be written out, and where silent overflow is genuinely what you want there are explicit functions that provide it. That is a different trade from the one most languages make, which is to leave the behaviour undefined and let the compiler do whatever is cheapest. Here it is defined, and the check happens while the program is running rather than while it is built. Set that beside bounds checking and the absence of null in safe mode and the safety story is coherent: the language trades compile-time work for runtime certainty, which is a defensible position for a systems language and also the reason its executable-performance goal is listed fourth rather than first.

Three pointer types, with the raw one fenced inside unsafe blocks

The memory safety section lists the strategies first and then the surface they produce. The strategies are automatic reference counting, strong typing, bounds checking and no raw pointers in safe mode. Then there are exactly three pointer types. A strong pointer, written as the type name, points at a reference-counted class. A weak pointer to the same thing becomes empty when what it points at is destroyed, which is why weak pointers cannot dangle. And a raw pointer to an arbitrary type is available, but only inside unsafe blocks. That qualifier is what makes the claim honest: the escape hatch exists and it is fenced rather than absent. Null pointers are not possible in safe mode, and where absence is a real possibility you wrap the pointer in an optional type, with a short spelling. Since reference counting is automatic, the empty weak pointer is the mechanism that tells you a value has gone rather than leaving you to find out by reading freed memory.

Structs copy, classes share, and the default visibility is opposite in each

Two ways to declare a structure, with opposite semantics and opposite defaults, and the page is careful to spell both out. A struct has value semantics: a variable holding one always has its own instance, and copying makes a deep copy. The example proves it in three lines with a comment saying the second variable is a deep copy and does not refer to the same struct. A class has reference semantics: copying copies a reference, and all objects are reference counted by default, which the page ties to the guarantee that objects are not accessed after being deleted. Then the defaults flip. Struct members are public by default; class members are private by default. Structs also get a generated constructor that takes every field by name, so you never write a positional initialiser. The asymmetry is deliberate, and it is the kind of thing you discover by writing your first class, finding the compiler rejects a field read from outside, and realising you had been relying on the struct rule.

Mutability is written into the receiver type

Member functions come in three kinds and the first parameter tells you which. A static function takes no receiver at all and can be called on the type. A non-mutating function takes the object itself and is not allowed to change it. A mutating function takes a mutable receiver, and the example spells out the consequence in a comment: it can only be called on a variable declared mutable. So whether you may modify an object is checked where you call it, not where it was defined, which is exactly what makes a non-mutating member function worth having. Alongside that sits the shorthand for reading a member, a leading dot that expands to the explicit form, described as a way to reduce repetitive noise in methods. That is the trade this language keeps making in the same place: fewer characters at the call site, more characters in the declaration. Whether that is a good trade depends on how much of your reading time is spent in bodies rather than in signatures.

The container builds the compiler as root on a full distribution base

The recipe is short and every line of it is load-bearing. It starts from a full current Ubuntu image rather than a build image, sets the frontend to non-interactive, installs a build toolchain plus CMake, Ninja, git, clang and the clang development headers, copies the whole tree in, and configures with clang as both the C and C++ compiler and a relative install prefix, then installs and symlinks the resulting binary into the system path. Three consequences follow from those choices. The install prefix is relative, which is why the symlink target has to be spelled out as an absolute path into the working directory. Nothing declares an unprivileged user, so the image runs as root. And there is no test step, so this produces a working compiler rather than a verified one. Elsewhere in the tree sit a bootstrap directory, a self-hosting directory, a directory for the language's own metadata and runtime, a Nix expression for the compiler itself, a separate test harness directory and twenty-six sample programs, one per feature area, including one for inline C++ and one for compile-time execution.

Editorial conclusion

Read Jakt as a language specification being written in public rather than a tool you would build a service in this month. What is settled is worth reading on its own: three pointer types with raw ones fenced inside unsafe blocks, no null in safe mode, reference counting by default, value semantics for structs against reference semantics for classes, explicit argument labels, and mutability carried in the receiver type. What is not settled is stated just as plainly, and the two items that would change how you write anything are an unchecked error-propagation feature and the absence of inferred enum scope. Two practical notes for anyone who does try it. Transpiling requires clang, so the toolchain is not self-contained, and on Windows the compiler sources need their line endings left alone, which the page asks you to set as a global Git option. The default branch was last pushed on 2026-08-21 and the repository publishes no releases.

Frequently asked questions

What is Jakt and what does it compile to?

A memory-safe systems programming language from the group behind SerenityOS, which currently transpiles to C++. Transpiling requires clang to be installed, and the documented workflow is one command to translate a source file and one to run the binary that lands in a build directory. The page carries a note that the language is under heavy development, and the standard library is described as being in its infancy.

Does Jakt have error handling yet?

Not the kind you would use every day. On the readability checklist, the item for error propagation with an error-or return type and dedicated try and must keywords is one of only two left unticked. The direction is visible elsewhere: string literals can be implicitly converted to a type whose trait name says the conversion throws, so a literal can already fail to parse, but the language has no mechanism yet for carrying that failure out of a function.

What pointer types does Jakt have?

Three. A strong pointer to a reference-counted class, written as the type name. A weak pointer to the same, which becomes empty when what it points at is destroyed. And a raw pointer to an arbitrary type, which is usable only inside unsafe blocks. Null pointers are not possible in safe mode, and a pointer that may be absent is wrapped in an optional type, with a shorter spelling available.

How do I build Jakt from source?

The page links to a bootstrap document in the documentation directory rather than inlining the steps. The container recipe shows what that involves: a current Ubuntu base, a build toolchain, CMake, Ninja, git, clang and its development headers, then a configure with clang as both compilers and a relative install prefix, an install step, and a symlink into the system path. On Windows, and not under the Linux subsystem, the page asks you to set a global Git option so line endings stay as newlines.

Official sources

  1. Issues
  2. License: BSD-2-Clause
  3. README
  4. SerenityOS/jakt on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/serenityos-jakt.svg)](https://hysenlabs.com/projects/serenityos-jakt)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/serenityos-jakt.svg)](https://hysenlabs.com/projects/serenityos-jakt)

Was this useful?