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.
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.
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.
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.
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 sdouble 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.
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.
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 step