tip预发布2026-11-12
This is an unreleased snapshot built from the main branch. Like a nightly but more up to date.
Language
- Reject files that mix tabs and spaces in block indentation, even on separate
lines or in separate functions. Use one style throughout each file;
whitespace inside strings, comments, and continuation alignment does not
affect this check. Diagnostics point to the first conflicting character.
[#3372]
- Give parameters explicit defaults, for example
def collect(items: list[int]=[]); a nullable type alone no longer makes an
argument optional. At a call such as collect(), the compiler supplies the
declared expression as the missing argument. Defaults may be literals,
constructor calls, or module-level values resolved in the function's own
module; explicitly passing None keeps it as None. Because defaults become
ordinary call arguments, int and bool values can stay unboxed, reducing
allocation and conversion overhead. Defaults used across modules also keep
their own protocol implementations when caller and callee share a name.
[#3211] [#3349]
- Reject str literals whose escaped bytes are not valid UTF-8 at parse
time. "\xc3\xa9" and adjacent "\xc3" "\xa9" both encode é,
while "\xff" is a syntax error; use bytes literals for arbitrary bytes.
The compiler also precomputes literal byte and character counts, avoiding
UTF-8 decoding during program startup. [#3301]
Compiler & Build
- Speed up compilation of large generated modules through compact name
storage, cheaper name comparisons, and concurrent content hashing. On an
M4 Pro, compact name storage reduced Acton compilation of half the generated
juniper_crpd module from 54.3 to 18.0 seconds, about three times faster,
excluding the native build. Content hashing in that workload fell from 25.8
to 4.6 seconds, and cached-interface writing from 11.3 to 2.0 seconds.
Further hashing improvements cut full-module hashing from 9.8 to 6.1 seconds.
Content hashes and generated C are unchanged. Existing cached module
interfaces (.tydb) are rebuilt for the new name encoding. [#3282] [#3284]
[#3286]
- Reduce allocation in generic code by sharing protocol witnesses, the objects
that supply operations such as equality and hashing for a type. Build reusable
witnesses once per module and share repeated constructions within a function
call when they depend on its protocol arguments, including those introduced
by default arguments. Use --witness-stats to report the constructions left
after sharing as one JSON line per compiled module. [#3354]
- Reduce protocol-dispatch overhead for builtin operations, including len(),
list.append(), list slicing, string and byte comparisons, and bigint and
complex arithmetic. Calls on known builtin types use native implementations
directly, omitting unused protocol arguments while preserving generic and
user-defined dispatch. [#3383]
- Generate less C and smaller binaries for programs with many closures by
sharing equivalent closure classes, call adapters, and serialization code.
Avoid redundant boxing in identity lambdas and unnecessary forwarding
continuations while retaining bounded C stack use. Generated closure support
lives beside each module's C file as <module>.closures.inc, making the C
easier to inspect and avoiding repeated rebuilds for packages named
Generated on case-insensitive filesystems. Common continuation, proc,
and action closures with reference captures now reuse runtime layouts and
support routines, further reducing generated C and native build time.
[#3262] [#3303] [#3380]
- Avoid allocating temporary attribute-name strings in generated
getattr__() methods, reducing allocation and garbage-collection work
during reflective property lookup. [#3374]
- Reduce allocation in synchronous for loops over builtin collections by
keeping compiler-created iterators on the C stack. This covers mutable and
immutable lists, dictionaries and sets, dictionary keys/values/items,
strings, bytes, bytearrays, arrays, bitarrays, and bitsets. Explicit iterator
variables, user-defined iteration, and iterators kept across suspension
retain their ordinary allocation behavior. [#3302]
- Inspect parameter lifetimes with --escape-analysis. The compiler now
checks Hashable.hash lifetimes across modules, and incremental builds
recheck dependent code when a helper's lifetime behavior changes. Existing
cached module interfaces are rebuilt for the new analysis data. [#3290]
- Correct calls of actor methods passed as proc parameters so assignments
and returns wait for the action's reply. Calls used as statements send
without waiting, including calls through forced unwrapping (!), optional
chaining (?.), and conditional expressions, preventing actor deadlocks.
[#3300]
- Correct reads of captured variables in nested functions and callbacks when
an enclosing try block reassigns them. None checks, type inspection, and
JSON encoding now see the captured value, while shadowing parameters and
local variables keep their own bindings. [#3363]
- Compile selected, renamed, and wildcard imports of module-level numeric
and boolean values correctly, avoiding crashes and C compilation errors.
[#3367]
- Preserve numeric result types in compound expressions involving fixed-width
integer shifts, such as (value >> n) & mask. Mixing an int shift count
with a signed or unsigned fixed-width operand no longer introduces invalid
pointer casts in generated C. [#3382]
- Keep symbols needed by dynamic module libraries in optimized macOS
executables, fixing release builds that fail to load a library with a
symbol not found in flat namespace error. [#3298]
- Keep cached output for modules with dots in their filenames, including
names such as y.root, and binaries for nested modules such as sub.x,
avoiding needless recompilation or reinstallation on every full build.
Watch mode and the language server remove cached interfaces, generated C,
and generated startup code for deleted modules from the correct project
directory. Full builds also remove generated startup code and binaries when
a module loses its root actor. [#3285] [#3289] [#3292]
- Reject invalid root actors with a compilation error and nonzero exit status,
instead of reporting success without producing an executable. The diagnostic
points to the actor and explains why it cannot be a root, including an
environment parameter inferred as a type other than Env. --root must name
an actor defined in the module. [#3355]
- Compile mutually dependent protocol extensions correctly when their
implementations are used inside methods, including equality methods
inherited through another protocol. [#3356]
- Compile fields, methods, parameters, and local variables named stdin,
stdout, stderr, or ERROR without collisions with C header macros,
including musl and Windows headers. Names with A_ prefixes remain distinct
from the compiler's escaped spellings. [#3364]
- Recheck dependents when a module loses its last public name, reporting the
missing export as a type error instead of failing during code generation.
Reuse only a module's own cached interface, even when another module on the
search path has the same name. [#3325]
- Report duplicate actor and function names in top-level declaration groups
at the second definition, instead of crashing the type checker, reporting
unrelated type errors, or generating invalid C. Duplicate-name checks also
scale better for large groups of declarations. Also reject duplicate methods
in classes, protocols, and extensions at the second definition, and report
a signature placed after its method as an illegal override. [#3274] [#3277]
- Upgrade the bundled Zig toolchain to 0.17.0 and update the bundled garbage
collector for Zig 0.17 compatibility. Add native optimization-mode f
v0.31.02026-10-08
This release brings major performance improvements across the compiler,
runtime, and standard library. Iteration is faster, many operations allocate
less, and actor scheduling and timers have lower overhead. Acton now uses its
own fork of the Boehm garbage collector, with performance improvements and
opt-in tuning options. The release also adds immutable collections, compact
numeric and bit containers, and a matrix module, alongside better performance
tools, cleaner project builds, and many other fixes and improvements.
Notable changes
Faster programs
Iteration now ends through ordinary control flow: next() returns a maybe
value instead of throwing an exception at the end. This makes some
iteration-heavy applications more than twice as fast. Range loops, numeric
conversions, hashing, and builtin operations allocate less, while actor
scheduling avoids unnecessary queue and synchronization work. Linux and macOS
now wait for timed messages on kernel timers instead of spinning, reducing CPU
time for timer-heavy workloads by more than 90%.
Garbage collection
Acton now uses its own fork of the Boehm garbage collector, with improvements
to parallel marking, thread-local allocation, and memory tracking. Improved
defaults apply automatically, while opt-in options let applications tune heap
growth, allocation budgets, mark storage, and dirty-page tracking through
Build.act. acton.rts.getgcinfo() reports the active mode and settings to
help inspect and compare configurations.
Linux and macOS applications can also choose mimalloc for C and native-library
allocations. This is separate from garbage collection of Acton objects.
Performance benchmarks: acton test perf
acton test perf measures individual benchmarks at a fixed or calibrated
workload size. Reports include timing, allocation and memory use, GC statistics,
and optional hardware counters. Benchmarks mark their measured operations with
t.loop(), so setup and cleanup around the loop do not count toward operation
time or allocation totals.
Measurements can be compared with a saved report or another Git revision. For
example, acton test perf --name my_test --compare git:main builds both project
versions and measures main against the current working tree, including
uncommitted changes, at a shared workload size. Runs use fresh processes and
balanced pairs to reduce noise. Both versions use the running compiler and
runtime; utils/perf-compare supports measuring changes to the compiler,
runtime, or builtins themselves.
Scaling studies: acton test scale
acton test scale shows how a benchmark's cost grows with its workload. The
benchmark defines what scale means, such as the number of elements to sort,
and reads the chosen size with t.scale(). As with performance benchmarks,
only the body of the t.loop() loop contributes to operation time and
allocation totals.
The study increases the scale, usually doubling it, and measures each size in
fresh processes until the observed growth settles over a broad range or a time
or memory limit stops it. The report shows a table of growth between sizes and
terminal charts of time, time per unit of scale, and allocated bytes.
A study can be compared with a saved study or a Git revision. By default,
acton test scale --compare git:main measures main and the current working
tree at the same completed workload sizes and overlays their curves. Explicit
end bounds allow both versions to explore independently.
New collections
Immutable ilist, idict, and iset values provide collection APIs without
mutation, with freeze() converting mutable collections into their immutable
forms. array, bitarray, and bitset offer compact storage for numeric and
Boolean workloads, while matrix adds numeric matrices with views that share
the underlying storage.
Language
- Add after now delay: call() for delays that start when the statement runs,
such as retry backoffs and pauses between requests. Plain after continues
to use the current message's scheduling baseline, keeping periodic work on a
steady schedule and catching up after stalls. [#3162]
- Add first-class immutable collection types by splitting collection protocols
into read-only and mutable parts. IIndexed, ISliceable, ISequence,
IMapping, and ISet expose access without mutation; ilist, idict, and
iset implement these read-only protocols, while list, dict, and set
add the corresponding mutation operations. The generic Freeze[A] protocol
and freeze() consume mutable collections into their immutable forms, with
hashable iset values usable as dictionary keys or nested sets. [#3122]
[#3152]
- Make augmented assignment use mutating protocol methods when a type overrides
them. set applies |=, &=, -=, and ^= in place; list and
bytearray apply += and *= in place; and bitset and bitarray update
their packed storage and size. Aliases observe these changes, while immutable
types retain value semantics and sum() leaves mutable start values
unchanged. [#3226] [#3230]
- End iteration through ordinary control flow instead of exceptions.
Iterator.next() and next() now return maybe[A], using just(value)
for items and nothing() for exhaustion. This makes some iteration-heavy
real-world applications more than twice as fast. [#3137]
- Treat mut and pure effects as temporarily interchangeable, allowing APIs
written with either effect to compose while immutable local mutation rules
are being redesigned. [#3084]
Compiler & Build
- Compile direct synchronous for loops over range() without allocating the
range object on the heap, and pass statically known range bounds as unboxed
integers. Nested range loops keep their private iterators in stack storage,
while range values that may escape the loop remain heap allocated. [#3189]
[#3224]
- Compile fixed tuple-literal assignments into scalar temporaries and stores,
avoiding a temporary tuple allocation while preserving left-to-right
evaluation and simultaneous-assignment semantics. [#3223]
- Compile conversions between statically known fixed-width numeric types
without boxing, while retaining range checks for narrowing conversions, and
keep builtin sequence indices unboxed across lookup and mutable operations
where supported. The reported nsieve 12 benchmark fell from 4.2 seconds to
1.9 seconds. [#3177]
- Generate allocation-free code for explicit next() and next() calls
even when producing and consuming the result are separated or the result is
tested inside a larger condition, while preserving ordinary maybe values
when they are passed elsewhere. [#3164]
- Compile protocols that inherit another protocol with fixed type arguments
without passing those type arguments to the wrong witness constructor, fixing
C generation for nested protocol inheritance. [#3098]
- Keep imported protocol witnesses in import and definition order, so broad
imported extensions no longer override more specific builtin witnesses and
change inferred types. [#3198]
- Reuse statically known witnesses reached through multiple inherited
protocols instead of constructing them repeatedly, including for list
indexing and mutation. This makes affected benchmark programs run at three
to six times their previous speed. [#3155]
- Compile augmented <<= and >>= assignments with an int shift count for
types such as bigint, matching the right-hand type accepted by ordinary
shift expressions. [#3158]
- Type check augmented ^= assignments for builtin and user-defined Logical
types instead of crashing the compiler. [#3163]
- Stop passing project-only module selection options to distribution packages
such as std, eliminating spurious Zig invalid option messages in verbose
build output and manually run build commands. [#3168]
- Allow Zig to use the active macOS SDK again
v0.30.02026-09-03
Language
- Complete soft-keyword parsing for declaration words such as actor,
class, extension, from, import, protocol, and type, keeping them
usable as names inside functions, classes, protocols, extensions, and actors
while reporting imports after module definitions as a clear parse error.
[#3038]
Compiler & Build
- Preserve hidden protocol-witness fields when importing constrained generic
classes, fixing subclass layout corruption and serialization round-trips for
generic classes subclassed from another module. [#3037]
- Avoid duplicate visible protocol witnesses when importing and defining
extensions, keeping witness lookup canonical when the same protocol/type
pair is available through rival modules or ancestry paths. [#3061]
- Cache imported module closures and attribute-owner lookups during type
checking, cutting repeated import and attribute scans so large generated
modules with many attribute selections type-check in seconds again instead
of minutes. [#3073]
- Resolve inherited protocol-witness slots during type checking instead of
late C generation, making witness classes complete for diamond, generic,
cyclic, and imported extensions while reporting conflicting inherited
signatures as compiler errors. [#3049]
- Use ThinLTO for non-debug Linux release builds, preserving cross-module
optimization while making final links faster and less memory intensive for
large projects. [#3060]
- Keep scalar parameters boxed when overriding generic class methods, so calls
through the generic method slot unbox values inside the callee correctly and
parameter rebinding does not mutate the caller's box. [#3043]
- Compile list, set, and dict comprehensions used in if, elif, and while
conditions without moving the generated comprehension helper out of scope.
[#3041]
- Deduplicate protocol witnesses for parameterized extensions by comparing
their schematic types, so generic classes with equivalent constraints do not
lose needed witness lookups when type parameter names differ. [#3065]
- Commit refreshed cached module interfaces before later compiler phases read
them, so incremental builds see a reliable front-end completion boundary and
keep progress reporting balanced. [#3068]
- Compile postfix ! on actor calls inside dict, list, and set comprehensions,
preserving effects and type conversions so generated C uses the correct
calling convention. [#3057]
- Compile forced unwrap and optional chaining through named and positional tuple
selections, and report unsupported row-rest selectors normally instead of
crashing the compiler. [#3055]
- Escape generated C identifiers that match C keywords using order-independent
lookup, including underscore-prefixed keywords and C23 typeof_unqual, so
generated code avoids reserved-word collisions. [#3044]
- Compile base, std, and generated project C with -fwrapv, making fixed-size
signed integer arithmetic wrap consistently in debug and release builds,
including overflowing left shifts. [#3050]
Runtime & Standard Library
- Decode JSON integers into Acton int or bigint values without losing
precision, including oversized signed and unsigned tokens, and encode
bigint values as JSON numbers by default with a bigintasstring option
for string-based consumers. [#3047] [#3053]
- Add Acton Object Notation support through new aon modules, with
source-aware parsing, deterministic encoding, nested sections, lists, named
tuples, comments, and direct conversion through the same data representation
as JSON. [#3077]
- Build tuples in one allocation by storing components inline with the tuple
object, reducing construction memory use and keeping deserialized tuples in
the same compact layout. [#3070]
- Handle set elements whose hashes use the high bit without hanging lookups,
keeping membership, deletion, reinsertion, resizing, and serialized
tombstones consistent across supported target widths. [#3075]
- Return both coalesced HTTP responses to pipelined http.Client callbacks,
preserving the parser remainder so later responses stay matched to the
correct outstanding request. [#3067]
- Fix base64.encode() and base64.decode() for empty byte strings, and make
invalid base64 input raise ValueError instead of aborting the process.
[#3066]
- Upgrade the bundled yyjson JSON library to 0.12.0. [#3052]
Testing & CI
- Add core-language regression tests for await values, exceptions, chaining,
fan-in, fan-out, queued messages, timers, and mixed outcomes, pinning the
observable semantics before runtime future/message handling is reworked.
[#3034]
- Stabilize the project-lock regression test by waiting for the child compiler
to report that it is blocked on the lock before releasing it. [#3069]
v0.29.12026-07-22
Language
- Add type aliases for naming existing types, including parameterized
aliases such as type Dict[K(Hashable)] = dict[K, str], so annotations,
casts, imports, witness resolution, generated docs, and completion can use
alias names while the compiler expands them for checking. [#3026]
- Treat top-level statement initiators such as actor, class, extension,
from, import, protocol, and type as soft keywords, so they can be
used as parameter or local names when they are not starting a declaration or
import. [#3027]
Compiler & Build
- Commit cached module-interface rows synchronously before reporting a module's
front pass as complete, making .tydb writes part of front-pass completion
and reporting write failures as normal compiler diagnostics. [#3019]
- Compile pure lambdas that return tuples without crashing eta reduction when
the lambda parameter itself is not tuple-typed. [#3024]
CLI & Project Workflow
- Show local project signatures without the project-prefix in acton sig
output, including imports and nested type and witness references. [#3030]
Runtime & Standard Library
- Fix str.splitlines() linebreak detection so newline and CRLF-separated
strings split into the expected lines. [#3023]
- Register failed continuations for serialization and reject unregistered
classes during serialization, preventing silent DB recovery corruption when
exceptions propagate to waiting actors. [#3031]
v0.29.02026-07-10
This release drastically improves compile times for modules that import very
large modules. The compiler tracks what specific names are used from each
import and selectively loads exactly those names, avoiding reading full
imported modules.
Language
- Derive Eq, Ord and Hashable for tuples whose components implement
them: tuples now support ==, the comparison operators and sorted(), and
work as dictionary and set keys. Equality and ordering are componentwise at
a single common type, so comparing tuples of different shapes (positional
vs named, or reordered field names) is a type error. Witness classes are
registered for serialization with preassigned class ids, shifting all
dynamically assigned class ids once. [#3009]
- Add a compiler-synthesized getattr__(name: str) -> ?value reflection
getter on every class, returning boxed instance attributes by their Acton
names while reserving getattr__ against user definitions. This lets
serializers reflect over attributes without forcing every attribute subtree
to stay reachable in large generated data models. [#2993]
- Compute bytes literal lengths correctly when a hex escape is immediately
followed by another hex digit, matching the generated split C string
fragments instead of letting the escape consume too much of the following
text. [#2996]
- Use tuple truth values safely in if, while, not, and conditional
expressions, fixing a panic when tuple bool returned an unboxed C
bool. [#3004]
Compiler & Build
- Track what specific names are used from each import and selectively load
exactly those names, avoiding full imported-module reads during type
checking, back passes, final C compilation, and cached implementation-hash
refreshes. Deferred back passes are enabled for normal modules, and tested
large-module cases see 10,000x improvements. [#2930] [#3000] [#3005]
[#3008]
- Speed up large generated modules by deduplicating external witnesses within
each protocol/type bucket instead of scanning every accumulated witness.
[#2999]
- Generate direct C calls for statically known builtin protocol methods on
builtin types, avoiding witness-table dispatch for those calls while keeping
the existing builtin witness values available to the generated code. [#2935]
- Continue primitive unboxing with bool, one of the most common value types
in Acton programs, representing it as an unboxed C bool through generated
code and builtin/runtime method tables while preserving inherited method
calls that return bool. [#2976]
- Preserve loop-carried locals assigned inside for loops in optimized release
builds, fixing cases such as explicitly provided argparse sub-command
options being lost under --release=fast. [#2981]
- Enable link-time optimization for non-debug Linux builds, including generated
projects, base, std, backend, and bundled runtime dependencies, while keeping
Debug builds fast. [#2982]
- Compile local bindings that shadow functions, including assignments inside
branches, without letting the global function name suppress the generated C
local variable declaration. [#2988]
- Preserve boxed values for primitives stored across awaited actor calls, so
augmented assignments update int and float locals safely after an
await instead of corrupting the boxed cell slot. [#2998]
- Compile continuation calls that return proc values through closure
conversion, fixing ### BAD contArg crashes in actonc --llift and other
passes that force the generated continuation type annotations. [#3014]
- Initialize module globals in bounded chunks and assign simple top-level
globals directly, avoiding startup stack overflows and oversized temporary
frames in modules with many generated globals. [#3015]
- Raise the compiler process open-file limit on startup, reducing
file-descriptor failures during large concurrent builds and cache-heavy
projects. [#3002]
- Avoid macOS cached-interface lock exhaustion after interrupted builds by
building vendored LMDB with process-shared mutexes instead of global named
semaphores. [#3007]
CLI & Project Workflow
- Prevent parallel acton test runs from hanging when a worker or output
reader fails, reporting the runner failure or captured output error instead
of waiting forever for a missing completion event. [#2972]
Runtime & Standard Library
- Add UDP support to net, with UDPCap, fixed-remote UDPConnection
sockets, bound UDPListener sockets, peer address and port reporting, and
listener replies to arbitrary peers. [#2989]
- Add serialize(obj) -> bytes and deserialize(data) -> value builtins for
in-memory object graph round-trips, preserving shared and cyclic references
and rejecting actors that cannot be serialized without a global reference
map. [#2997]
- Report missing or empty process.Process and process.RunProcess commands
through on_error, and mark failed spawns as not running so follow-up
process operations are safely ignored. [#2986]
- Serialize bigint values with their own class id so multi-word integers
round-trip through Acton serialization instead of being decoded as normal
int rows. [#2994]
- Serialize bytes values with their own class id so they round-trip as
bytes instead of deserializing as str. [#2995]
- Preserve shared object references during deserialization by using the same
integer key representation for back-reference registration and lookup,
fixing repeated references that previously decoded as missing values. [#3011]
- Fix json.Json actor actions so decode, decode_list, encode, and
encode_list call the shared JSON implementations instead of recursively
calling themselves. [#3017]
Packages & Distribution
- Speed up macOS CI by reducing the PR test matrix to faster macOS 26 runners,
while release artifacts still target macOS 15 for both the Zig target and
Haskell binary deployment floor and publication stays gated on macOS 15 smoke
tests. [#2992]
- Speed up package CI by building Debian and RPM packages from the same
prebuilt dist/ tree, avoiding the slow, hard-to-cache Debian package
rebuild while sharing installed-payload validation and package version checks
across both package formats. [#2987]
- Expand ecosystem CI coverage with standalone acton-ssh and acton-grpc
test jobs, and drop the stale standalone ncurl job now that its source
lives in StratoWeave. [#2974]
- Compress RPM payloads with zstd, and check for the zstd tool before
building RPM packages. [#3001]
Documentation
- Document the type checker's witness environment invariants, active and closed
witness lifetimes, enumeration order, and possible exact-lookup split in the
compiler developer guide. [#2978]
v0.28.32026-06-23
This release is another proxy workaround release. Acton now keeps one more
dependency path away from Zig's own fetcher because Zig still cannot reliably
fetch HTTPS archives through an HTTP CONNECT proxy.
Packages & Distribution
- Pre-seed Zig's package cache for transitive .url dependencies declared by
path-based Zig packages in build.zig.zon, using Acton's proxy-aware HTTP
downloader instead of letting Zig fetch those archives during final
compilation. [#2970]
- This covers Acton package dependencies such as acton-zlib that carry a
local Zig package whose own manifest pulls a source archive like
zlib_upstream; previously acton fetch could succeed through the proxy
and then acton build still failed later when Zig tried to resolve the
nested archive itself.
- The workaround is intentionally boring: parse enough ZON to find dependency
url, hash, path, and lazy fields, follow local path deps, seed
non-lazy remote archives into the same Zig cache, and avoid cycles or
duplicate downloads.
- We only need this because Zig's CONNECT proxy support is still broken for
this path: it sends an absolute-form request URI inside the tunnel and the
origin closes the connection, typically surfacing as invalid HTTP response:
HttpConnectionClosing.
- The proxy regression harness now builds a project that depends on a real
Acton package with a transitive Zig dependency, so proxy-only networks cover
the frustrating "fetch succeeded, final compile failed anyway" case.
v0.28.22026-06-22
Package and dependency operations now consistently use HTTP CONNECT proxies.
Linux release artifacts also target glibc 2.28 for older distro compatibility.
Compiler & Build
- Avoid arm64 parser crashes in concurrent builds by compiling Acton.Parser
without GHC full-laziness floating, keeping parser closures local to each
parse while preserving parser and compiler concurrency. [#2964]
Packages & Distribution
- Use a common proxy-aware HTTP path for dependency downloads, package
metadata, package index updates, and archive rehashing, so acton install,
acton pkg add, acton pkg upgrade, and acton zig pkg add work behind
HTTP CONNECT proxies. [#2963]
- Earlier proxy fixes were spot solutions and not universal.
- Network failures use the same proxy diagnostic instead of leaking raw
http-client request records, and connection-level proxy failures fail
fast while server-side rate-limit and transient errors still retry.
- The proxy regression harness covers package index updates and package
upgrades in addition to dependency archive downloads.
- Target glibc 2.28 for Linux release builds on both x86_64 and aarch64,
using the Makefile's pinned Zig glibc target instead of deriving it from the
builder container. [#2959]
- Compiler-linked static dependencies such as zlib, GMP, and tinfo must come
from Acton's bdeps/out tree, so missing build-time archives fail clearly
instead of falling back to host libraries built for a newer libc.
v0.28.12026-06-20
Compiler & Build
- Report the final Zig build step duration from the live progress task shown
during acton build, keeping the final build log consistent with the visible
CLI progress timer and avoiding a misleading completion line when the final
build fails. [#2939]
- Read bundled base and std .tydb interface databases as immutable system
inputs, so installed distributions and --syspath roots can reuse read-only
interfaces without LMDB lock files while project and dependency caches keep
normal locking. [#2945]
- Distribution builds remove generated LMDB lock files from packaged base/std
caches and normalize data.mdb permissions so release tarballs ship
world-readable interface databases.
- Box unboxed numeric values before they flow through value use sites,
fixing assignments, conditionals, isinstance, and and/or expressions
after primitive unboxing. [#2943]
CLI & Project Workflow
- Use local module names without redundant project prefixes in imports,
signature inspection, build and test output, diagnostics, snapshot
directories, and stale-output pruning while keeping project-qualified
identities for internal caches and dependency layout. [#2937, #2941, #2946,
#2949]
- Dependency lib modules can be imported and inspected with the dependency
package name, for example import depa and acton sig depa, instead of
spelling the generated dep_a.lib module.
Packages & Distribution
- Publish signed RPM package repositories at rpm.acton.now and
rpmtip.acton.now, with signed package and repository metadata for DNF/YUM
clients and install docs for stable and tip repositories. [#2957]
- Restore httpproxy and httpsproxy handling when x86_64 Linux release
builds fetch package dependencies, fixing a proxy-only-network regression from
the 0.28 build and linking changes where Acton connected directly even though
earlier Acton releases used the proxy. [#2956]
- Dependency download failures report the proxy variable and proxy
environment Acton used, with a hint for checking proxy configuration.
- A make test-proxy Docker harness and CI job validate release artifacts on
amd64 and arm64 hosts behind a proxy-only network.
- Add RPM packaging via make rpms, producing packages from an existing
dist/ tree and validating them in Fedora CI by building, installing, and
compile-testing the generated RPMs. [#2948]
- Prune upstream tests, scripts, maintenance files, and docs when extracting
distribution dependencies, keeping release artifacts focused on runtime
files. [#2948]
- Declare ca-certificates as a Debian package dependency and install it in the
container image, so package downloads over TLS work on stripped-down systems
without relying on another package to provide system CA roots. [#2952]
- Force Acton's macOS Zig SDK fallback for spawned Zig builds even when
DEVELOPER_DIR is already set, fixing Homebrew source builds with macOS 26
Command Line Tools. [#2938]
- The Homebrew formula installs lsp-server-acton explicitly and avoids
copying dist/bin into the formula prefix.
Documentation
- Index CHANGELOG.md into Ask Acton separately from the guide docs, so release
notes are available in chat search and changelog updates refresh that source
independently. [#2944]
v0.28.02026-06-16
By a wide margin, the fastest Acton to date! Massive compilation speedups,
mostly from optimized data structures (HashMaps, IntSets etc) rather than
linear list searches, concurrent type checking and concurrent parsing etc -
which makes the compiler over 5000x for a particularly large test module
(~300MB .act file). A new back pass compilation technique, which we call
Deferred Back Passes (DBP), selects only the interesting parts of a module for
compilation, providing another massive speedup.
Compiler & Build
- Add concurrent top-level type checking for total statements, allowing the
compiler to check independent top-level definitions in parallel while keeping
source-order semantics for non-total statements. [#2773, #2782]
- Verbose and timing builds now report inferred signatures for non-total
statements, making it easier to add explicit signatures and unlock more
concurrent checking.
- Type errors from independent total statements are collected into multiple
diagnostics instead of stopping at the first failing statement.
- Use a fixed worker pool with bounded lookahead, improving memory behavior
and performance for modules with many independent top-level definitions.
- Parse modules in parallel by splitting top-level statement chunks across
parser workers, reducing parser latency for large source files while
preserving source-order results. [#2787]
- --parse-serial keeps the whole-file parser available for debugging and
fallback comparisons.
- Module-suite validation now uses a set-based duplicate check, avoiding
quadratic validation time in large projects.
- Report parser progress percentages during builds, giving useful feedback for
very large files before type checking starts. [#2784]
- Report hashing as its own front-pass progress phase in CLI and LSP builds, so
large modules show source, implementation, interface, and dependency hashing
work instead of appearing stuck after type checking. [#2905]
- Type-checking and hashing progress updates are paced to keep detailed
progress reporting from slowing large-module builds through excessive UI
churn.
- Report active back-pass progress for normalize, deactorize, CPS, lambda
lifting, boxing, code generation, render, and write steps, so CLI and LSP
builds show which generated-code phase is currently running. [#2808, #2853]
- Generate unboxed code for bounded integer and float values through the boxing
and code-generation passes, a major reduction in wrapper allocation and
box/unbox traffic for numeric Acton programs. Fewer boxes also means less
memory traffic and less garbage for the runtime to collect, so numeric-heavy
code can improve both by doing faster primitive work and by putting less
pressure on the memory subsystem and garbage collector. [#2824, #2890]
- Builtin, base, and standard-library C implementations now use raw C values
for unboxed integer and float operations where the Acton type is known.
- Cached module interfaces from older boxed-primitive compiler versions are
treated as stale and rebuilt instead of being reused across the
representation change.
- As one example, the existing examples/sumto.act benchmark at 30 million
integer additions dropped from about 960 MB of GC heap allocation to about
54 KB, with reported GC time falling from about 2.05 seconds to 0 ms and
wall time from about 1.47 seconds to about 0.12 seconds.
- In a standalone run of the DCT performance fixture at size 2,000, GC heap
allocation dropped from about 768 MB to about 384 MB, reported GC time from
about 1.58 seconds to about 0.79 seconds, and wall time from about 1.14
seconds to about 0.65 seconds.
- Preserve each module's import context in cached module interfaces, so builds,
acton sig, documentation, and completion can reuse cached interfaces without
losing imported class and protocol information. [#2779]
- Store cached module interfaces in LMDB-backed .tydb directories instead of
monolithic .ty files, keeping corrupt or version-mismatched entries as safe
cache misses while adding keyed records for headers, imports, names, hashes,
dependency hashes, and typed statements. [#2819, #2855, #2858, #2889, #2896,
#2907]
- Full reads reconstruct source-order environments from explicit order keys,
and cache copy and cleanup paths now handle directory artifacts.
- Cache values are encoded with persist, improving .tydb write and read
time for large generated interfaces while treating older binary-encoded
caches as stale rebuilds.
- Dependency hashes are indexed by provider module and name, so stale-cache
checks can skip unchanged modules cheaply and only inspect the dependency
names a cached module actually used when an upstream module changed.
- Preparing .tydb entries for names, hashes, extensions, and typed
statements now happens in strict concurrent chunks before the LMDB write
transaction, and CLI progress distinguishes preparation from writing.
- Read transactions retry transient LMDB lock-table setup errors with a fresh
environment and a longer backoff window, matching the existing retry path
for environment opens.
- Build and statically link LMDB from a pinned bundled dependency so compiler
builds do not depend on the host LMDB installation.
- Run front-output writes asynchronously after front passes, so cached
interface writes, .tydb copies, and documentation rendering can overlap with
downstream work while watch and LSP builds discard stale-generation writes.
[#2851]
- Add deferred back passes for very large modules, letting the compiler run the
normal front passes first and then generate code only for declarations that
are reachable from the program, similar to tree shaking, dead-code
elimination, or link-time optimization for generated Acton modules. [#2843,
#2884]
- Automatic selection starts at modules with at least 1,000 top-level names;
--dbp MOD[:NAME,...] can force focused experiments, and --no-dbp
disables both heuristic and forced selection.
- Deferred back passes prune typed modules to interested names, root actors,
local dependency closures, and class/protocol extension dependencies before
running the existing back-pass chain.
- Modules at explicit Build.act library boundaries compile normally so
declared library outputs keep their full generated surface.
- Skip build-time HTML documentation pages for modules with more than 10,000
top-level names while keeping compilation and cached interfaces intact. The
generated project documentation index still lists those modules without
linking to missing pages, and explicit acton doc FILE.act requests still
render the requested source file. [#2884]
- Fix concurrent .tydb reads so shared interface caches retry transient LMDB
lock-file setup races and propagate environmental errors with their real
cause instead of reporting a missing interface. [#2841]
- Speed up compiler environment lookups, scans, module-environment rewrites,
attribute queries, solver candidate enumeration, substitutions, and witness
resolution in large modules by indexing active names, signature and
definition locations, state-variable and type-variable names, solver
candidate sets, term substitutions, and type witnesses; separating closed
imports and finalized top-level names from live local bindings; avoiding
temporary inherited-attribute lists for single-attribute queries; reading
substitution state once per traversal; narrowing used-substitution tracking to
active entries; and deduplicating reserved names with a hash index while
preserving source-order semantics. [#2789, #2796, #2797, #2799, #2800, #2816,
#2833, #2837, #2839, #2840, #2924]
- Speed up documentation rendering and generated-name hashing by indexing
documentation type lookups and hashing internal/generated names without
rendering prefix
v0.27.02026-05-08
Added
- Add precise content-hash based build output reuse throughout the compiler
pipeline for optimal compilation [#2447, #2497, #2581, #2674]
- Acton now decides whether previous typechecking results, generated build
outputs, and downstream work are still valid from source and dependency
content instead of relying on file modification times
- Cached module interfaces record source hashes, module-level public and
implementation hashes, and per-name source / public / implementation hashes
- Per-name dependency hashes let the compiler track exactly which names a
declaration depends on, so unrelated edits do not force whole modules or
downstream dependents to be rebuilt
- Public type-signature changes rerun front passes for affected downstream
modules; implementation-only changes can refresh implementation hashes and
rerun back passes / code generation without forcing unrelated typechecking
- When hashes match, cached build output is reused directly instead of
reparsing, re-typechecking, or regenerating work that is already fresh
- Add concurrent module compilation across the build graph. [#2524, #2527]
- The compiler schedules modules as soon as their dependencies are ready,
allowing independent parts of a project to typecheck in parallel
- Front passes and back passes are separated, so dependent modules can start
once an interface is available while normalization, C generation, and other
back-end work continue in parallel
- Ready modules are prioritized by critical path so large dependency branches
do not leave available workers idle
- This keeps project builds, watch mode, and LSP feedback responsive while
still producing the same deterministic build outputs
- Add VS Code editor support through the Acton language server. [#2487, #2753]
- The VS Code extension can now show Acton syntax and type errors inline,
using the same parser and typechecker as acton build
- Completion suggests attribute names, function and method argument names,
and other relevant source-level names
- Hover shows Acton information for names under the cursor
- Editor state is kept in memory for fast lookups, so completion and
diagnostics stay responsive while typechecking continues
- Add acton doc command for generating documentation [#2274, #2284, #2292,
#2293, #2295]
- Supports multiple output formats (text, markdown, HTML)
- Default is to open browser into HTML docs when window environment is
available, in terminal we fall back to colored text output. Use acton doc
-t to force text / terminal output.
- Plain acton doc will show module index in browser - for terminal output, a
source file must be given, like acton doc src/foo.act -t
- Text output is colored for output to TTY (terminal), piping output falls
back to plain ASCII output. Also honors NO_COLOR env var
- HTML supports:
- colorized output of types etc
- inter-module links to type definitions
- explanatory tooltips for generic types
- Add optional chaining and forced unwrapping for optional values [#2672, #2726]
- person?.residence?.name returns None when any step is None
- person!.residence!.name raises ValueError when a required step is
unexpectedly None
- Both forms support attribute access and method calls via ?. / !., plus
indexing and slicing via ?[...] / ![...]
- Add acton sig to inspect inferred type signatures using the same
project-aware module and dependency resolution as acton build. [#2746]
- Useful when an error says foo.bar does not have attribute X, since
acton sig foo.bar resolves names like the compiler does: first as bar
in module foo, then as module foo.bar
- Add docstring support throughout compiler and AST [#2282]
- Parse docstrings in AST declarations [#2269, #2270, #2271, #2565, #2736]
- Unescape docstrings in NameInfo
- Allow module docstrings before imports
- Add short options support for argparse module [#2289]
- Add global command-line options support to actonc [#2291]
- Add new Hashable protocol and hash() builtin function [#2255]
- Replace hash method with new composable hashing approach
- Types implement .hash(self, hasher) method to update a stateful hasher object
- The hasher accumulates state from multiple fields: self.x.hash(h); self.y.hash(h)
- Use the hash() function to get hash values: h = hash(my_object)
- All built-in types implement Hashable protocol
- Uses fast wyhash algorithm via Zig implementation
- Parser / Syntax errors are now prettier [#2306, #2307, #2309]
- Replace basic error rendering with elegant unicode style using Diagnose library
- Better structured error reporting using Megaparsec's ADT typed error system
- Improve error messages for type variable name violations
- Clear hints explaining that single uppercase letters are reserved for type variables
- Show cases possibilities of new parser error diagnostics
- Plain ASCII example (in terminal is even prettier):
``
[error Parse error]: Invalid name (reserved for type variables)
+--> test/syntaxerrors/err41.act@1:7-1:8
|
1 | class Z(value):
: ^
: - invalid name 'Z'
:
| Hint: Single upper case character (optionally followed by digits) are reserved for type variables. Use a longer name.
-----+
``
- Improve string interpolation parsing [#2321]
- String parsing has been rewritten from scratch
- String interpolation now works by default in all string literals (no f-prefix required)
- Both "hello {name}" and f"hello {name}" support interpolation
- The change to interpolate normal strings is backwards incompatible, any
strings containing curly braces now need to be escaped or be converted to
raw strings, i.e. "{" -> "{{" or r"{"
- Backwards compatibility for classic % operator style is currently
maintained, i.e. NO interpolation is performed for s = "hello %s, here is
{}" % name, so curly braces are treated literaly
- NOTE: %-operator style formatting will be deprecated in the future
- Parser support nested interpolation strings (thought the necessary rewrites
- Properly handle escape sequences in interpolated strings
- Support complex expressions in interpolations including slices ({arr[1:3]})
- Better error messages for malformed format specifications and many other cases
`
ERROR: [error Syntax error]: Empty format specifier after ':'
╭──▶ test@1:27-1:27
│
1 │ f"Unbalanced format {name:}:10}"
•
• ╰╸ Empty format specifier after ':'
─────╯
`
- Let repr() and type() accept optional values [#2373]
- repr(None) returns "None" and type(None) returns "None"
- More convenient than needing wrapper functions for optional values
- Add webex PR merge notification [#2372]
- Recognize projects by Build.act & build.act.json [#2358]
- Accept Build.act (new ideal), build.act.json (common), or Acton.toml (existing)
- Check for src/ directory presence for robustness
- Allow any expression after after [#2342]
- Previously limited to local functions, now supports method calls, actor methods, etc.
- after 1.5: obj.method() and after 0.1: remote_actor.action() are now valid
- Add utils/update-changelog.sh script to update this file (CHANGELOG.md) using Claude - it's a good prompt!
- Allow logging of optional values [#2382]
- Change logging data parameter type from dict[str, value] to dict[str, ?value]
- Enables structured logging with None values like {"user": None, "count": 42}
- Add acton build FILE for file-oriented builds through the main CLI. [#2471,
#2592]
- Add acton build --watch` for fast edit/build feedback loops. [#2571]
- Watch mode performs an initial project build and then keeps running,
rebuilding automatically when source files change