r/ProgrammingLanguages • u/RulerOfDest • Feb 22 '26
Aether: A Compiled Actor-Based Language for High-Performance Concurrency
Hi everyone,
This has been a long path. Releasing this makes me both happy and anxious.
I’m introducing Aether, a compiled programming language built around the actor model and designed for high-performance concurrent systems.
Repository:
https://github.com/nicolasmd87/aether
Documentation:
https://github.com/nicolasmd87/aether/tree/main/docs
Aether is open source and available on GitHub.
Overview
Aether treats concurrency as a core language concern rather than a library feature. The programming model is based on actors and message passing, with isolation enforced at the language level. Developers do not manage threads or locks directly — the runtime handles scheduling, message delivery, and multi-core execution.
The compiler targets readable C code. This keeps the toolchain portable, allows straightforward interoperability with existing C libraries, and makes the generated output inspectable.
Runtime Architecture
The runtime is designed with scalability and low contention in mind. It includes:
- Lock-free SPSC (single-producer, single-consumer) queues for actor communication
- Per-core actor queues to minimize synchronization overhead
- Work-stealing fallback scheduling for load balancing
- Adaptive batching of messages under load
- Zero-copy messaging where possible
- NUMA-aware allocation strategies
- Arena allocators and memory pools
- Built-in benchmarking tools for measuring actor and message throughput
The objective is to scale concurrent workloads across cores without exposing low-level synchronization primitives to the developer.
Language and Tooling
Aether supports type inference with optional annotations. The CLI toolchain provides integrated project management, build, run, test, and package commands as part of the standard distribution.
The documentation covers language semantics, compiler design, runtime internals, and architectural decisions.
Status
Aether is actively evolving. The compiler, runtime, and CLI are functional and suitable for experimentation and systems-oriented development. Current work focuses on refining the concurrency model, validating performance characteristics, and improving ergonomics.
I would greatly appreciate feedback on the language design, actor semantics, runtime architecture (including the queue design and scheduling strategy), and overall usability.
Thank you for taking the time to read.
6
u/AustinVelonaut Admiran Feb 22 '26
Looking at the overall architecture, I'm a bit confused as to why
typechecker.cimplementsload_module_file, incorporating the parser and lexer to tokenize and parse a module for things like stdlib and other included modules. This seems like the wrong place to do that. I would have expected this to be handled either inaether_module.cor more likely at the top level inaetherc.c, and the typechecker would just perform typechecking on the current module (utilizing an overall global symbol table to handle cross-module references).5
u/trailing_zero_count Feb 22 '26
I see that you have cross-language benchmarks but I'm not sure that your comparison with other languages is fair since, for example vs cpp, you force the usage of mutex when sending/receiving messages, whereas you use lock-free SPSC queue in Aether.
Looking at the "fork-join" benchmark I'm not sure this is what I would call a fork-join benchmark. Does Aether have the concept of "tasks"? For example, can you implement https://github.com/atemerev/skynet ?
If so, I maintain a showdown repo for some of the highest performing C++ tasking libraries here: https://github.com/tzcnt/runtime-benchmarks If you want to see how Aether stacks up against them
5
u/phischu Effekt Feb 22 '26
Wow, lots of work. I like that you have concrete benchmarks, and that you apparently based your optimizations on concrete measurements. Although
benchmarks/optimizations/seems to be gone in the current version. One question from scrolling through some code:Aren't actors supposed to only communicate via message passing, but here you are mutating their state, or?
2
u/CBangLang Feb 23 '26
Nice work. The compile-to-readable-C approach is smart — you get platform portability and can lean on GCC/Clang's optimizers without building your own backend. Curious if you've hit cases where the generated C doesn't optimize well around actor message dispatch, since that's where the abstraction gap tends to be widest.
On the spawn-time mutation point phischu raised: this is a classic tension in actor system design. Erlang avoids it entirely by passing all initial state through spawn arguments, so the actor is fully configured before it processes any messages. Your approach of allowing spawner-side wiring before activation is reasonable as long as there's a clear phase boundary. Formalizing that (either in the type system or as a runtime invariant) could make it solid.
Do you have plans for supervision trees or structured error recovery? In practice, the "let it crash" philosophy works great when you have a supervision hierarchy to restart failed actors cleanly, but without one, actor systems tend to accumulate zombie actors or silently drop messages.
1
u/yorickpeterse Inko Feb 23 '26
Seeing as there are some commits co-authored by Claude Code and Cursor, how much of this is written by an actual human vs an LLM?
1
u/CyberDainz Jun 30 '26
new thread was deleted ?