Acton Programming Language

Concurrent by design.
Simple by choice.

Acton is an actor-based language for writing reactive, robust concurrent systems with a powerful static type system and clear, direct code.

Read the guide Try Acton online Install locally

Actors are the unit of state, isolation, and concurrency.

Types are checked before your system runs.

Many actors can cooperate without turning control flow into a maze.

Latest release: v0.27.0 Release notes

Simple, familiar syntax makes programs simple to express and keeps users productive. The compiler infers and checks types, giving you static correctness guarantees without type noise.

def greeting(name):
    return "Hello {name}"

actor main(env):
    names = ["Ada", "Vint", "Edsger"]
    for name in names:
        print(greeting(name))
    env.exit(0)

Expressive types, inferred at use write code with the ease of a dynamic language while keeping the guarantees of static checking. Acton infers the types you leave out and checks the operations you use. Mistakes are caught before the program runs, when they are cheapest to fix.

Click Show types to see the generic type variables and constraints inferred in this example.

def first(items):
    return items[0]

def maximum(a, b):
    if a > b:
        return a
    return b

actor main(env):
    numbers = [10, 20, 30]
    names = ["Ada", "Vint", "Edsger"]

    number = first(numbers)
    name = first(names)
    bigger = maximum(number, 20)
    later = maximum(name, "Vint")
    env.exit(0)

Static types give the compiler facts.

Armed with static types, Acton can generate efficient code for fast execution. With concrete types known at compile time, this DCT loop turns into the kind of optimal C you would write by hand: double locals, direct arithmetic, and ordinary while loops. Read more in the unboxing post.

import math

def dct(k, n, l):
    return math.cos(math.pi/l * (n + 0.5) * k)

def dct_sum(l):
    s = 0
    k = 0
    while k < l:
        n = 0
        while n < l:
            s += dct(k, n, l)
            n += 1
        k += 1
    return s

double dctQ_U_dct(double U_1k, double U_2n, double U_3l) {
    double U_4N_tmp = cos((((mathQ_pi->val / U_3l) * (U_2n + 0.5)) * U_1k));
    return U_4N_tmp;
}

double dctQ_U_5dct_sum(double U_6l) {
    double U_7s = 0;
    double U_8k = 0;
    while ((U_8k < U_6l)) {
        double U_9n = 0;
        while ((U_9n < U_6l)) {
            U_7s += dctQ_U_dct(U_8k, U_9n, U_6l);
            U_9n += 1;
        }
        U_8k += 1;
    }
    return U_7s;
}

Serial code. Concurrent execution.

Each actor runs sequentially and owns its state, making behavior easy to reason about. You call methods, not share memory. Concurrency emerges from composing actors, making systems structured, predictable, and easier to evolve.

actor Collector(expected, env):
    var seen = 0
    var total = 0

    def result(name, value):
        print("done {name}: {value}")
        seen += 1
        total += value
        if seen == expected:
            print("sum: {total}")
            env.exit(0)

actor Worker(name, collector):
    def checksum(start, stop):
        print("start {name}")
        total = 0
        for n in range(start, stop):
            total += (n % 97) * (n % 97)
        collector.result(name, total)

actor main(env):
    collector = Collector(4, env)

    Worker("A", collector).checksum(0, 1000000)
    Worker("B", collector).checksum(1000000, 2000000)
    Worker("C", collector).checksum(2000000, 3000000)
    Worker("D", collector).checksum(3000000, 4000000)

Productive with a rich standard library.

Useful batteries are included: HTTP, networking, JSON, logging, time, files, testing, and more.

This example fetches JSON over HTTPS, decodes the response, and keeps the surrounding actor responsive while network I/O completes.

import http
import net

actor main(env):
    connect_cap = net.TCPConnectCap(net.TCPCap(net.NetCap(env.cap)))

    def on_connect(client):
        client.get("/products/1", on_response)

    def on_response(client, response):
        product = response.decode_json()

        print("status:", response.status)
        print("title:", product["title"])
        print("price:", product["price"])
        client.close()
        env.exit(0)

    def on_error(client, error):
        print("HTTP error:", error)
        env.exit(1)

    http.Client(
        connect_cap,
        "dummyjson.com",
        on_connect,
        on_error,
    )

Actor-based concurrency

Actors are built into the language, not bolted on as a library convention. That gives programs a natural unit for state, communication, and scheduling.

Static checks, less ceremony

Acton has static types and type inference. You can add annotations where they clarify intent, without turning every local binding into type noise.

Reactive by default

Build systems from actors that react to calls, callbacks, timers, and I/O. The result is concurrent code that remains explicit about where work happens.

Next steps

Read the guide, run code, or ask a question.

Read the guide Try Acton online Ask Acton Full install guide

Install locally

Use the Acton APT repository on Debian or Ubuntu, or Homebrew on macOS.

Debian / Ubuntu

sudo install -m 0755 -d /etc/apt/keyrings
sudo wget -q -O /etc/apt/keyrings/acton.asc https://apt.acton-lang.io/acton.gpg
sudo chmod a+r /etc/apt/keyrings/acton.asc
echo "deb [signed-by=/etc/apt/keyrings/acton.asc] http://apt.acton-lang.io/ stable main" | sudo tee -a /etc/apt/sources.list.d/acton.list
sudo apt-get update
sudo apt-get install -qy acton

macOS

brew install actonlang/acton/acton

Concurrent by design.Simple by choice.