CLI tool
jfecher/ante avatar
jfecher/ante

Ante: a low-level functional language built on Rust-style ownership

A safe, easy systems language. These tests have commands in them which the goldentests library uses to run the ante compiler and check its output for each file against the expected output contained within comments of that file.

2,375 stars121 forksRustMIT

At a glance

What is it?
Ante is a research-oriented systems language that combines functional syntax with Rust-like ownership and effect handlers. This review covers its design, build process, and the practical caveats of adopting a compiler that last shipped in 2017.
Who is it for?
Adopt Ante if you are a compiler researcher or a language hobbyist interested in safe shared mutability and effect handlers, and you are comfortable with a pre-1.0 codebase that has not seen a release since 2017. Do not use it for production systems or anything requiring a stable toolchain.
Can I use it commercially?
Yes. MIT 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 3 days ago.
What is it written in?
Mainly Rust, 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

  • jfecher/ante2,375 ★ · +57
Star history
Repository2026-07-282026-11-15
jfecher/ante2.3k2.4k

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

Editorial analysis

What Ante actually is and who it targets

Ante is a low-level functional language that explores safe, shared mutability, effect handlers, and related ideas. The README positions it as built on a core of ownership and borrowing rules similar to Rust, but with a syntax that encourages high-level approaches that can later be optimized with low-level details. The target audience is not application developers. It is people who want to experiment with language design, particularly around mutable aliasing and effect systems. The repository itself calls the compiler early state and welcomes contributors, which sets expectations: this is a research artifact, not a production tool.

The core mechanism: ownership, borrowing, and effects in one type system

The language combines several mechanisms in a single type system. The example in the README shows a function that takes a mutable reference and a borrowed reference, uses an effect annotation to allow failure, and calls a trait method via implicits. The key idea is that you can pass the same mutable reference twice, as in `baz x x`, because the borrowing rules are designed to allow safe aliasable mutation. Traits are resolved through implicit parameters, which the README says avoids forced newtype wrappers. Effects are declared as part of the function signature, and the `Fail` effect lets you call `fail ()` without explicit error handling. This is a different approach from Rust's strict aliasing rules, and it is the central experiment of the project.

Building the compiler: LLVM 21.1 or the C backend

The build process is documented in detail, and it is not trivial. You must clone with submodules, otherwise clang will complain about a missing `aminicoro.c`. The default backend requires LLVM 21.1, and older versions are not supported. If you have LLVM installed with sources, `cargo install --path .` should work. Otherwise, you can set `LLVM_SYS_211_PREFIX` to the path from `llvm-config --obj-root`. For those without LLVM, the README offers `cargo install --path . --no-default-features`, which uses the C backend. On Windows, building LLVM from source is described as notoriously difficult, and the recommendation is to skip the LLVM backend unless you specifically need it. Nix users get a development environment via `nix-shell` or `nix develop`, and the project is available in the unstable nixpkgs branch.

Testing with goldentests: how the compiler is verified

The repository uses a custom testing approach. Each file in the `examples` directory contains commands in comments, and the goldentests library runs the Ante compiler against each file and compares the output to the expected output embedded in those comments. You run the tests with `cargo test --test goldentests`. This is a neat mechanism because it keeps test expectations close to the code, but it also means the test suite is tightly coupled to the compiler's current output. Any change to error messages or formatting would require updating many files. The README asks contributors to make sure PRs pass these tests, which is a reasonable gate for a compiler project.

The biggest limitation: a frozen timeline

The last release is v0.8.0 from 2017-07-23, and the last push to master is the same date. The README mentions an official Discord and a mostly inactive subreddit, but the repository itself has not seen activity in years. This is a genuine red flag for adoption. The language design may be interesting, but the compiler is effectively unmaintained. If you encounter a bug, there is no active development to fix it. The documentation links to a website and a language tour, but it is not confirmed whether those pages are still live or up to date. For any serious use, you would be relying on a snapshot of a research project.

Choosing Ante versus Rust or another experimental language

The obvious alternative is Rust itself, which shares the ownership and borrowing core but has a mature compiler, a standard library, and a large ecosystem. Ante differs by adding effect handlers and allowing safe shared mutability, which Rust deliberately forbids. If your goal is to explore those language features, Ante is a direct experiment. Another alternative is a language like Koka, which also has effect handlers, though Koka is higher-level and does not focus on low-level memory management. The README does not mention Koka, but the difference in approach is clear: Ante tries to combine low-level control with functional abstractions, while Koka runs on a garbage-collected runtime. If you need production reliability, Rust is the choice. If you need effect handlers and can tolerate a research-grade tool, Ante is one of the few options.

Maintenance and license: what you are signing up for

The project is licensed under MIT, which is permissive and allows commercial use, modification, and redistribution without copyleft obligations. That is a positive for adoption, but it does not compensate for the lack of maintenance. There is no mention of a changelog, a migration guide, or a stability policy. The compiler is at version 0.8.0, which means breaking changes are possible between releases, and there have been none in years. The build system depends on a specific LLVM version, and the README warns that older LLVM versions are unsupported. If you build with the C backend, you avoid that dependency, but the C backend may not support all language features. The README does not specify what the C backend lacks, so you would need to verify that against the codebase before relying on it.

Editorial conclusion

Adopt Ante if you are a compiler researcher or a language hobbyist interested in safe shared mutability and effect handlers, and you are comfortable with a pre-1.0 codebase that has not seen a release since 2017. Do not use it for production systems or anything requiring a stable toolchain. Before investing time, verify that the current master branch still builds with your LLVM version, or plan to use the C backend, since LLVM 21.1 is a hard requirement for the default backend and older LLVM versions are unsupported.

Frequently asked questions

What is jfecher/ante?

A low-level functional language written in Rust, exploring safe shared mutability, effect handlers, and borrowing rules similar to Rust's, with an emphasis on readability. The repository contains the compiler, a language server, a C interface package, a standard library, and the example files that double as its test suite.

How do I install the ante compiler?

Clone with submodules, then run `cargo install --path .` if the required toolchain version is already installed with sources. The exact version is 21.1, and older versions are not supported. If you do not have it, install through your package manager or build it from source, or install with `--no-default-features` to use the C backend instead.

Can ante be built on Windows?

The default configuration cannot be used as-is, because the prebuilt toolchain binaries do not ship with the appropriate library files on Windows. The documentation says you must build the toolchain from source for that backend, and recommends building without it unless you are specifically testing that backend. Building the toolchain there additionally requires Visual Studio 2017 or later.

How does ante test its compiler?

Through a golden test suite that compiles each file in the examples directory and compares the output against expected output embedded in comments in that file. It is run with `cargo test --test goldentests`, and the examples are organised by compiler stage: parser, name resolution, type checking, intermediate representation, code generation, and regressions.

What version of ante is current?

The manifest in the repository declares 0.1.0, while the newest published release is 0.8.0 from 2017. The last commit is dated 2026-10-02, so the tree is current and there is no recent release to install; the repository documents building from the branch rather than fetching a release.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
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/jfecher-ante.svg)](https://hysenlabs.com/projects/jfecher-ante)

Star history chart for your README

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

Was this useful?