Actus

Actus is an experimental low-level systems programming language focused on explicit semantic roles, deterministic ownership, and a small compile-time safety core.

Read the complete Actus Handbook for language syntax, ownership, modules, standard-library APIs, compiler workflow, examples, and contributor guidance.

The project is in an early alpha stage. The current architecture is built around four roles:

• erg — an exclusive owned binding that may read, mutate, borrow, move, or be dropped;
• abs — a temporary shared read-only borrow;
• dat — a linear ownership transfer into a callee.
• ins — an exclusive call-scope loan that temporarily suspends the owner and returns exclusive mutation access when the call ends.

Strict conformance is the release-validation mode for the compiler and standard library. Use actus check --strict, actus build --strict, and actus test --strict to require fail-closed source, ownership, architecture, documentation, target, lockfile, and execution validation. The non-strict workflow remains available for interactive development, but is not release evidence. See ADR-0041 and the Phase 18 acceptance report.

Actus Alpha supports lexical borrows and single-origin abs returns. A returned view is non-owning and remains tied to one caller owner; it cannot be stored in a longer-lived structure. The compiler tracks borrow records, derives Frozen and Suspended access states, and inserts deterministic cleanup at scope boundaries.

Project status

The language specification and compiler architecture are under active development. The compiler is being bootstrapped in Rust and currently emits native object files through a Rust-native Cranelift backend. The native alpha slice supports integer parameters and locals, arithmetic expressions, lexical scopes, loop control flow, integer returns, nested structs, field mutation, and struct methods. See examples/structs_demo.act for a complete executable example.

Language style, module visibility, import conventions, and formatting rules are documented in Actus Language Style and Conventions.

Module implementation scope and facade-bounded public APIs are specified by ADR-0047 and tracked in the Phase 20 roadmap.

The verified Alpha package, ownership, standard-library, and CLI workflow is documented in the Alpha User Guide.

New projects use the dependency-free core runtime by default. To opt into the compiler-owned standard library, select it when creating the project:

actus new my_program --runtime std
cd my_program
actus check
actus build --emit exe

The equivalent manifest setting is:

[build]
runtime = "std"

The compiler resolves canonical imports such as std::io from the packaged standard library. It does not require copying library/std into the project or adding an absolute host path. Freestanding runtime templates remain target-aware work for the embedded capability gate.

The implemented operator, checked-cast, and bounded-indexing contracts are listed in the operator reference.

Actus is designed to provide C-level control through raw pointers, MMIO, precise layouts, and inline assembly behind explicit unsafe boundaries, while keeping ownership and borrowing checks active in safe code. See ADR-0012 for the accepted low-level design.

Build and run

Build the compiler and run the introductory example through the frontend:

cargo run -- check examples/hello.act

Emit a native object file:

cargo run -- build examples/hello.act --emit obj -o examples/hello.o

Build a native executable directly through the system linker:

cargo run -- build examples/hello.act --emit exe -o examples/hello
./examples/hello
echo $?

Build and execute a temporary native binary without keeping the artifact:

cargo run -- run examples/loop_ssa.act

The command returns the Actus program's exit code and removes its temporary executable.

The example returns 42. Object files and native executables are local build artifacts and are excluded from version control.

Toolchain configuration

Basic project build settings are read from the root Actus.toml manifest. The linker can be overridden without changing source code by setting ACTUS_LINKER:

[package]
name = "my_program"
version = "0.1.0"
entry = "main"

ACTUS_LINKER=clang cargo run -- build examples/hello.act --emit exe -o examples/hello

The default linker is cc. Hosted executables currently require the configured entry verb to be main; custom entry symbols will be supported with a future freestanding/linker-target configuration. Language semantics, ownership rules, and borrow safety are not configurable project options.

Native libraries can be supplied through manifest-relative search paths:

[build]
library_paths = ["native"]

[[build.libraries]]
name = "example"
kind = "static"

Foreign C declarations must use an explicit unsafe boundary:

unsafe extern "C" verb rand() -> Int;

The initial C boundary supports Int values and Buffer pointers. abs and dat are restricted to opaque resource pointers; ins uses the same native pointer representation while its exclusive-loan contract is enforced before code generation. Foreign pointer returns are owned by the Actus caller. Unsupported layouts are rejected before linking.

The ownership extensions are specified in ADR-0020 and ADR-0021.

Run the complete test suite with:

cargo test

Design

See MANIFESTO.md for the ownership model, borrow rules, cleanup semantics, syntax direction, and compiler roadmap.

Open source

Actus is open-source software released under either the MIT License or the Apache License, Version 2.0, at the recipient's option. Contributions, design discussions, and implementation feedback are welcome as the language evolves.

License

Copyright (c) 2026 Giorgi Magradze

Licensed under either the MIT License or the Apache License 2.0, at the recipient's option. The Actus and Actus names and logos are governed separately by TRADEMARKS.md.