A low-level functional language

For exploring algebraic effects, safe shared mutability, and other novel features

Ante is in active development

Ante is currently in active development and the compiler is in a very early state. In addition, the features listed on this website detail the language itself rather than the subset that is implemented by the current compiler. If you are interested to see which features are implemented, please look at the github page linked below. Otherwise, if you just want to see the current design of the language, check out the language tour.


Ante aims to help bridge the gap between low-level languages like C++/Rust and higher level garbage-collected languages like Java, OCaml, or Haskell. Ante aims to make developing programs easier by allowing patterns like shared mutability which allow for more design flexibility while still remaining thread safe and memory safe.

Safe Shared Mutability

Shared mutability is a common cause of bugs in other languages. In Ante, not only is it safe, it is zero-cost. The type system will prevent unsafe operations on mutably shared references at compile-time.


Common patterns like looping and handling effects have syntax sugar to cut down on repetitive code while keeping things explicit.

Simple Module System

Ante’s module system mirrors the file tree and is easy to understand and easy to build as a result.

Always-Incremental Compilation

Incremental compilation metadata is distributed along with source code. This avoids the need for each user to rebuild most libraries or applications.

High & Low Level language

To try to bridge the gap between high and low level languages, ante adapts a high-level approach by default, maintaining the ability to drop into low-level code when needed.

No Lifetime Variables

Ante’s simplified reference rules mean you never need to write another lifetime variable again.

The compiler is on GitHub

All are welcome to contribute!


Recent posts

Read the latest blog posts

Simplification Through Addition

By Jake Fecher on 2024-03-17

Ante’s goal was always to be a slightly higher level language than Rust. I always imagined Ante to fill this gap in language design between higher-level garbage collected languages like Java, Python, and Haskell, and lower level non-garbage collected languages like C, C++, and Rust. I still think there’s room there for a language which tries to manage things by default but also allows users to manually do so if needed as an optimization.

Continue reading

Algebraic Effects, Ownership, and Borrowing

By Jake Fecher on 2024-02-20

Introduction Algebraic Effects are a useful abstraction for reasoning about effectful programs by letting us leave the interpretation of these effects to callers. However, most existing literature discusses these in the context of a pure functional language with pervasive sharing of values. What restrictions would we need to introduce algebraic effects into a language with ownership and borrowing - particularly Ante?1 Ownership Consider the following program: effect Read a with read : Unit -> a the_value (value: a) (f: Unit -> b can Read a) : b = handle f () | read () -> resume value This seems like it’d pass type checking at first glance, but we can easily construct a program that tries to use the same moved value twice:

Continue reading

Achieving Safe, Aliasable Mutability with Unboxed Types

By Jake Fecher on 2024-01-29

This is part of Ante’s goal to loosen restrictions on low-level programming while remaining fast, memory-safe, and thread-safe. Background When writing low-level, memory-safe, and thread-safe programs, a nice feature that lets us achieve all of these is an ownership model. Ownership models have been used by quite a few languages, but the language which popularized them was Rust. In Rust, the compiler will check our code to ensure we have no dangling references and cannot access already-freed memory (among other errors).

Continue reading