{"id":52091112,"url":"https://github.com/aether-lang-dev/aether","last_synced_at":"2026-08-04T06:00:54.107Z","repository":{"id":340061594,"uuid":"944236568","full_name":"aether-lang-dev/aether","owner":"aether-lang-dev","description":"An actor-based systems language that compiles to readable C. Native, no VM, no garbage collector.","archived":false,"fork":false,"pushed_at":"2026-07-31T20:13:43.000Z","size":40799,"stargazers_count":99,"open_issues_count":45,"forks_count":6,"subscribers_count":2,"default_branch":"main","last_synced_at":"2026-07-31T20:14:35.673Z","etag":null,"topics":["actor-model","actors","capability-security","compiler","compiles-to-c","concurrency","language","no-gc","programming-language","systems-programming"],"latest_commit_sha":null,"homepage":"https://aether-lang.dev","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/aether-lang-dev.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG-archive.md","contributing":"CONTRIBUTING.md","funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null,"disclosure":null},"funding":{"github":["nicolas-maman"],"patreon":null,"open_collective":null,"ko_fi":null,"tidelift":null,"community_bridge":null,"liberapay":null,"issuehunt":null,"lfx_crowdfunding":null,"polar":null,"buy_me_a_coffee":null,"thanks_dev":null,"custom":null}},"created_at":"2025-03-07T02:23:27.000Z","updated_at":"2026-07-31T20:14:16.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/aether-lang-dev/aether","commit_stats":null,"previous_names":["nicolasmd87/aether","aether-lang-org/aether","aether-lang-dev/aether"],"tags_count":465,"template":false,"template_full_name":null,"purl":"pkg:github/aether-lang-dev/aether","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/aether-lang-dev%2Faether","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/aether-lang-dev%2Faether/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/aether-lang-dev%2Faether/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/aether-lang-dev%2Faether/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/aether-lang-dev","download_url":"https://codeload.github.com/aether-lang-dev/aether/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/aether-lang-dev%2Faether/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":36263568,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-07-20T02:08:10.276Z","status":"online","status_checked_at":"2026-08-04T02:00:06.901Z","response_time":57,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["actor-model","actors","capability-security","compiler","compiles-to-c","concurrency","language","no-gc","programming-language","systems-programming"],"created_at":"2026-08-04T06:00:53.379Z","updated_at":"2026-08-04T06:00:54.085Z","avatar_url":"https://github.com/aether-lang-dev.png","language":"C","funding_links":["https://github.com/sponsors/nicolas-maman"],"categories":[],"sub_categories":[],"readme":"# Aether Programming Language\n\n[![CI](https://github.com/aether-lang-dev/aether/actions/workflows/ci.yml/badge.svg)](https://github.com/aether-lang-dev/aether/actions/workflows/ci.yml)\n[![Windows](https://github.com/aether-lang-dev/aether/actions/workflows/windows.yml/badge.svg)](https://github.com/aether-lang-dev/aether/actions/workflows/windows.yml)\n[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)\n[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS%20%7C%20WASM%20%7C%20Embedded-lightgrey)]()\n[![Website](https://img.shields.io/badge/website-aether--lang.dev-8A2BE2)](https://aether-lang.dev/)\n\nErlang-style actors, Rust-grade capability discipline, and Go-flavored ergonomics, compiled to readable C.\n\n**Website: [aether-lang.dev](https://aether-lang.dev/)**\n\n## Overview\n\nMost languages treat \"what may this program touch?\" as a deployment problem. Aether makes it a language problem: code runs against an explicit grant list, enforced three times over. At compile time, `--emit=lib` starts capability-empty and the host opts modules in with `--with=fs,net,os`. At scope level, `hide` and `seal except` stop ambient names from leaking into any lexical block, a closure, a trailing-block DSL, an actor handler. At runtime, an `LD_PRELOAD` shim checks libc itself (`open*`, `connect`/`bind`, `execve`, `mmap`, `dlopen`, `getenv`) against the same grants, inherited across `execve`. The mix is Pony's object capabilities, Java's removed SecurityManager, and a fraction of gVisor; see [Containment Sandbox](docs/containment-sandbox.md) for the threat model and known bypass surface.\n\nConcurrency is actor-shaped: Erlang-style `actor` / `receive` / `!` with automatic multi-core scheduling, lock-free mailboxes, and migration that converges chatty actors onto one core. The compiler emits readable C, not bytecode and not a VM, which is an implementation choice rather than the pitch: it buys native speed, direct linking against existing C libraries, and a runtime that ports anywhere a C toolchain reaches.\n\n**Where it sits on the OO ↔ FP spectrum:** structs are plain data, behaviour is free functions, closures + trailing blocks are first-class, Aether leans **closer to functional than OO**, sitting near Go and Rust in the hybrid middle of the paradigm spectrum. There are no classes, no inheritance, no method dispatch; the one piece of OO machinery present is the actor (stateful, encapsulated behind a message boundary, no polymorphism). See [Language Reference § Paradigm placement](docs/language-reference.md#paradigm-placement).\n\nThe load-bearing features, one line each:\n\n- **Actor concurrency**, scheduled across cores for you: lock-free messaging, locality-aware spawning, work stealing. See [Actor Concurrency](docs/actor-concurrency.md).\n- **Config IS code**: library APIs double as typed, sandboxable configuration DSLs via trailing-block closures, so operators run real Aether instead of YAML. See [Config IS Code](docs/config-is-code.md).\n- **Polyglot host, both directions**: run Lua / Python / Perl / Ruby / Tcl / JS in-process under the same grant list, or embed Aether into Python, Java, and Ruby through `--emit=lib` typed SDKs with per-guest memory and deadline caps. See [Embedding \u0026 emit=lib](docs/emit-lib.md).\n- **Production networking in the stdlib**: an HTTP server with TLS, HTTP/2, WebSocket, SSE, and zero-copy `sendfile(2)`, plus an nginx-class reverse proxy. See [HTTP Server](docs/http-server.md) and [Reverse Proxy](docs/http-reverse-proxy.md).\n- **A deliberate memory model**: manual-first with `defer`, automatic string-ownership tracking, and `requires`/`ensures` contracts that compile out at zero cost. See [Memory Management](docs/memory-management.md).\n- **Go-flavored ergonomics**: type inference, `(value, err)` multi-value returns, `@derive(eq)`, and a single `ae` command for build / run / test / fmt / packages. See [Language Reference](docs/language-reference.md).\n- **Portability as a feature**: Linux, macOS, Windows, FreeBSD, WebAssembly, and embedded targets; cross-compile with `ae build --target=\u003ctriple\u003e`. See [Architecture](docs/architecture.md).\n\n## Benchmarks\n\nCross-language benchmark suite based on the [Savina Actor Benchmark Suite](https://dl.acm.org/doi/10.1145/2687357.2687368), 11 languages × 5 patterns (ping-pong, counting, thread ring, fork-join, skynet). Both the benchmark runner and the visualization server are written in Aether, dogfooding the stdlib.\n\n```bash\nmake benchmark    # Builds runner, runs all 55 benchmarks, opens UI at http://localhost:8080\n```\n\nSee [Performance Benchmarks](docs/performance-benchmarks.md) for methodology and [benchmarks/cross-language/](benchmarks/cross-language/) for source.\n\n## Quick Start\n\n### Install\n\n**Linux / macOS / FreeBSD, prebuilt binary (no toolchain, no build):**\n\nEvery [release](https://github.com/aether-lang-dev/aether/releases/latest) ships a ready-to-run tarball (`ae` + `aetherc` + stdlib) named `aether-\u003cversion\u003e-\u003cplatform\u003e.tar.gz`, where `\u003cplatform\u003e` is one of `linux-x86_64`, `macos-arm64`, `macos-x86_64`, `freebsd-x86_64`. Grab the URL for your platform from the [latest release](https://github.com/aether-lang-dev/aether/releases/latest), then extract and add its `bin/` to your `PATH`:\n\n```bash\n# Example (substitute the current version + your platform from the Releases page):\nVER=0.458.0; PLATFORM=linux-x86_64\ncurl -fsSL \"https://github.com/aether-lang-dev/aether/releases/download/v${VER}/aether-${VER}-${PLATFORM}.tar.gz\" | tar xz -C ~/.local\nexport PATH=\"$HOME/.local/bin:$PATH\"     # add to ~/.bashrc / ~/.zshrc to persist\nae version\n```\n\n**Linux / macOS, build from source (remote one-liner, no clone):**\n\n```bash\ncurl -sSL https://raw.githubusercontent.com/aether-lang-dev/aether/main/get.sh | sh\n```\n\nFetches a pinned source tarball, builds the toolchain (Aether compiles to C, so the only prerequisites are a C compiler + GNU make, no tests run), and installs to `~/.local` (sudo-free). Pin a version with `AETHER_REF=\u003ctag\u003e` (see the [releases page](https://github.com/aether-lang-dev/aether/releases) for tags), or change the prefix with `PREFIX=/usr/local` (system-wide; needs sudo). Add `~/.local/bin` to your `PATH` if it isn't already.\n\n**Linux / macOS, full clone install** (editor extension, `ae version` management, shell-PATH setup, `~/.aether` layout):\n\n```bash\ngit clone https://github.com/aether-lang-dev/aether.git\ncd aether\n./install.sh\n```\n\nInstalls to `~/.aether` and adds `ae` to your PATH. Restart your terminal or run `source ~/.bashrc`, `~/.zshrc`, or `~/.bash_profile`.\n\n**Windows, download and run:**\n\n1. Download `aether-*-windows-x86_64.zip` from [Releases](https://github.com/aether-lang-dev/aether/releases)\n2. Extract to any folder (e.g. `C:\\aether`)\n3. Add `C:\\aether\\bin` to your PATH\n4. **Restart your terminal** (so PATH takes effect)\n5. Run `ae init hello \u0026\u0026 cd hello \u0026\u0026 ae run`\n\nGCC is downloaded automatically the first time you run a program (~80 MB, one-time), no MSYS2 or manual toolchain setup required.\n\n**All platforms, install, upgrade, and switch versions:**\n\n```bash\nae version list              # see all available releases (newest first)\nae upgrade                   # install the latest release and switch to it\nae install                   # install the latest release (or `ae install \u003ctag\u003e` for a specific one)\nae use \u003ctag\u003e                 # switch to an already-installed version\n```\n\nRun `ae version list` (or check the [latest release](https://github.com/aether-lang-dev/aether/releases/latest)) to find the current tag; there's no need to hard-code one.\n\n(The longer `ae version install \u003cv\u003e` / `ae version use \u003cv\u003e` forms still\nwork and are equivalent to `ae install` / `ae use`.)\n\n### Your First Program\n\n```bash\n# Create a new project\nae init hello\ncd hello\nae run\n```\n\nOr run a single file directly:\n\n```bash\nae run examples/basics/hello.ae\n```\n\n### Editor Setup (Optional)\n\nInstall syntax highlighting for a better coding experience:\n\n**VS Code / Cursor:**\n```bash\ncd editor/vscode\n./install.sh\n```\n\nThis provides:\n- Syntax highlighting with TextMate grammar\n- Custom \"Aether Erlang\" dark theme\n- `.ae` file icons\n\n### Development Build (without installing)\n\nIf you prefer to build without installing:\n\n```bash\nmake ae\n./build/ae version\n./build/ae run examples/basics/hello.ae\n```\n\n### The `ae` Command\n\n`ae` is the single entry point for everything, like `go` or `cargo`:\n\n```bash\nae init \u003cname\u003e           # Create a new project\nae run [file.ae]         # Compile and run (file or project)\nae build [file.ae]       # Compile to executable\nae check [file.ae]       # Type-check without compiling (skips codegen + link)\nae fmt [--check] [path]  # Format source (stdin, or .ae files/dirs in place)\nae test [file|dir]       # Discover and run tests\nae examples [dir]        # Build all example programs\nae add \u003chost/user/repo\u003e  # Add a dependency (any git host)\nae repl                  # Start interactive REPL\nae cache                 # Show build cache info\nae cache clear           # Clear the build cache\nae version               # Show current version\nae upgrade               # Install the latest release and switch to it\nae install \u003cv\u003e           # Install a specific release (latest if omitted)\nae use \u003cv\u003e               # Switch to an installed version\nae version list          # List all available releases\nae help                  # Show all commands\n```\n\nIn a project directory (with `aether.toml`), `ae run` and `ae build` compile `src/main.ae` as the program entry point. You can also pass `.` as the directory: `ae run .` or `ae build .`.\n\n**Using Make (alternative):**\n\n```bash\nmake compiler                    # Build compiler only\nmake ae                          # Build ae CLI tool\nmake test                        # Run runtime C test suite\nmake test-ae                     # Run .ae source tests\nmake test-all                    # Run all tests\nmake examples                    # Build all examples\nmake -j8                         # Parallel build\nmake help                        # Show all targets\n```\n\n### Building on Windows\n\nThe Aether build is GNU-make based. Use one of the two paths below, `nmake` from a Visual Studio Developer Prompt **will not work** (the Makefile uses GNU-only syntax that NMAKE can't parse).\n\n**Just running Aether? Skip this section** and use the [release binary](https://github.com/aether-lang-dev/aether/releases), no MSYS2 setup required.\n\n**Building from source, recommended (MSYS2 / MinGW-w64):**\n\n1. Install [MSYS2](https://www.msys2.org/) and open the **MSYS2 MinGW 64-bit** shell (not the bare MSYS shell).\n2. Install the toolchain:\n   ```bash\n   pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-make \\\n             mingw-w64-x86_64-openssl mingw-w64-x86_64-zlib \\\n             mingw-w64-x86_64-ca-certificates pkg-config make bc\n   ```\n3. Clone and build:\n   ```bash\n   git clone https://github.com/aether-lang-dev/aether.git\n   cd aether\n   make ci   # full suite: compiler, ae, stdlib, REPL, C tests, .ae tests, examples\n   ```\n\nFor HTTPS to verify certs, the `mingw-w64-x86_64-ca-certificates` package above provides the bundle at `/mingw64/etc/ssl/certs/ca-bundle.crt`. The runtime auto-detects it; if your install is in a non-standard location, export `SSL_CERT_FILE` to the bundle's Windows path.\n\n**Native MSVC (cl.exe / nmake):** not currently supported as a full build path, tracker [#99](https://github.com/aether-lang-dev/aether/issues/99). The MSVC matrix job in CI verifies our public headers parse under `cl.exe` so a future native MSVC port stays feasible, but `make` (the build system itself) requires GNU make. The MSYS2 MinGW build above is the supported source-build path for Windows today.\n\n## Project Structure\n\n```\naether/\n├── compiler/           # Aether compiler (lexer, parser, codegen)\n│   ├── parser/        # Lexer, parser, tokens\n│   ├── analysis/      # Type checker, type inference\n│   ├── codegen/       # C code generation, optimizer\n│   └── aetherc.c      # Compiler entry point\n├── runtime/           # Runtime system\n│   ├── actors/        # Actor implementation and lock-free mailboxes\n│   ├── config/        # Platform detection, optimization tiers, runtime config\n│   ├── memory/        # Arena allocators, memory pools, batch allocation\n│   ├── scheduler/     # Multi-core scheduler + cooperative single-threaded backend\n│   └── utils/         # CPU detection, SIMD, thread portability\n├── std/                # Standard library\n│   ├── string/         # String operations\n│   ├── file/           # File operations (open, read, write, delete)\n│   ├── dir/            # Directory operations (create, delete, list)\n│   ├── path/           # Path utilities (join, basename, dirname)\n│   ├── fs/             # Combined file/dir/path module\n│   ├── collections/    # List, HashMap, Vector, Set, PQueue\n│   ├── list/           # Dynamic array (ArrayList)\n│   ├── map/            # Hash map\n│   ├── intarr/         # Fixed-size packed int buffer\n│   ├── json/           # JSON parser and builder\n│   ├── http/           # HTTP client + server (TLS, keep-alive, h2, WS, SSE, metrics)\n│   │   ├── client/         # Builder client (request builder, full response, JSON sugar)\n│   │   ├── middleware/     # CORS, basic/bearer/session auth, rate-limit, real-IP, vhost, gzip, static, rewrite, error pages\n│   │   ├── proxy/          # Reverse proxy: upstream pool, LB (RR/LC/iphash/WRR), health, cache, circuit breaker\n│   │   └── server/h2/      # HTTP/2 framing via libnghttp2 (h2 + h2c + ALPN + GOAWAY + concurrent dispatch)\n│   ├── tcp/            # TCP client and server\n│   ├── net/            # Combined TCP/HTTP networking module\n│   ├── cryptography/   # Hash family (SHA-2/3, BLAKE2, RIPEMD, Whirlpool, Tiger, Skein, SM3), HMAC, HKDF/PBKDF2/scrypt/Argon2, DRBG\n│   ├── zlib/           # One-shot deflate/inflate\n│   ├── math/           # Math functions and random numbers\n│   ├── io/             # Console I/O, environment variables\n│   ├── os/             # Shell execution, command capture, env vars, ISO-8601 time\n│   └── log/            # Structured logging\n├── contrib/            # Optional / opinionated modules outside std/\n│   ├── cryptography/   # Extra crypto beyond std.cryptography\n│   ├── parsers/        # xml_expat (SAX XML via libexpat)\n│   ├── sqlite/         # SQLite bindings (open, prepare, bind, step, column, ...)\n│   ├── templating/     # liquid (Shopify-Liquid port) + native emitter DSL\n│   ├── tinyweb/        # Server-side request/response DSL\n│   └── host/\u003clang\u003e/    # Embed js, lua, perl, python, ruby, tcl, duktape,\n│                       #   tinygo, go, java, factor, racket, rhombus in-process\n├── tools/              # Developer tools\n│   ├── ae.c            # Unified CLI tool (ae command)\n│   └── apkg/           # Project tooling, TOML parser\n├── tests/              # Test suite (runtime, syntax, integration, regression)\n├── examples/           # Example programs (.ae files)\n│   ├── basics/         # Hello world, variables, arrays, etc.\n│   ├── actors/         # Actor patterns (ping-pong, pipeline, etc.)\n│   └── applications/   # Complete applications\n├── docs/               # Documentation\n└── docker/             # Docker (CI, dev, WASM, embedded)\n```\n\n## Language Example\n\n```aether\n// Counter actor with message handling\nmessage Increment {}\nmessage Decrement {}\nmessage Reset {}\n\nactor Counter {\n    state count = 0\n\n    receive {\n        Increment() -\u003e {\n            count = count + 1\n        }\n        Decrement() -\u003e {\n            count = count - 1\n        }\n        Reset() -\u003e {\n            count = 0\n        }\n    }\n}\n\nmain() {\n    // Spawn counter actor\n    counter = spawn(Counter())\n\n    // Send messages\n    counter ! Increment {}\n    counter ! Increment {}\n    counter ! Decrement {}\n    counter ! Reset {}\n    counter ! Increment {}\n\n    // Wait for all messages to be processed\n    wait_for_idle()\n\n    println(\"Final count: ${counter.count}\")\n}\n```\n\n## Closures and Builder DSL\n\nAether closures take three shapes after a function call. They look similar but have different semantics, picking the right one is the language's main lever for separating DSL structure from runtime behaviour.\n\n| Mode | Syntax | Semantics |\n|------|--------|-----------|\n| **Immediate** | `func() { block }` | Runs inline at the call site, used for DSL structure |\n| **Closure** | `func() \\|x\\| { block }` | Real closure with explicit params, hoisted to a C function |\n| **Callback** | `func() callback { block }` | Real closure that captures enclosing scope, no params needed |\n\n```aether\n// Immediate, declarative structure, runs during construction\npanel(\"Settings\") {\n    button(\"OK\")\n    button(\"Cancel\")\n}\n\n// Closure, explicit params, deferred invocation\napply_twice(x: int, f: fn) { return call(f, call(f, x)) }\ndoubler = |x: int| -\u003e x * 2\nprintln(apply_twice(3, doubler))    // 12\n\n// Callback, captures from scope, runs when invoked\ncounter = ref(0)\nbtn(\"increment\") callback { ref_set(counter, ref_get(counter) + 1) }\nbtn(\"decrement\") callback { ref_set(counter, ref_get(counter) - 1) }\n```\n\nThe compiler distinguishes them at parse time, which is what makes the sandboxing story (above) work: `hide`/`seal except` checks happen against the hoisted form of `closure` and `callback` blocks, so a `seal except req, res` on a callback body genuinely prevents the body from reaching outer scope. Immediate blocks inherit the caller's lexical scope by design, they're structure, not callbacks.\n\nInspired by Smalltalk blocks, Ruby's blocks/procs, Groovy closures, and Kotlin/SwiftUI's trailing-block DSLs. See [Closures and Builder DSL](docs/closures-and-builder-dsl.md) for the builder-context mechanism, ref cells, and full DSL pattern; see [Closure lineage and runtime tradeoffs](docs/design/closure-lineage-and-runtime-tradeoffs.md) for why Aether keeps closure-shaped values without adopting a Lisp/Smalltalk runtime.\n\n## Config IS Code\n\n**Don't ship a YAML loader.** If your Aether library has a \"start the thing\" surface, HTTP server, daemon, agent, scheduler, test rig, expose it as a closure-DSL block and let the operator's \"config\" be a `.ae` file they run with `ae run`. The pattern collapses YAML → templating → second-language-DSL (HCL, Helm) → embedded-scripting all into one thing: real Aether, type-checked, sandboxable, with the full stdlib available when the operator needs it.\n\n```aether\nimport avnserver\n\nmain() {\n    avnserver.serve {\n        host(\"127.0.0.1\")\n        port(9990)\n        superuser_token(env(\"SUPER_TOKEN\"))   // computed at config time\n        repo(\"alpha\", \"/srv/alpha\")\n        repo(\"beta\",  \"/srv/beta\")\n    }\n}\n```\n\nSame file is config, validation, conditional logic, and the entry point. No second parser, no second type system, no template language. Sandboxing (`--emit=lib --with=...`, `hide`, `seal except`) keeps it safe to accept untrusted configs as the embedded-DSL case demands. See [Config IS Code](docs/config-is-code.md) for the full progression (YAML → HCL → Pulumi → here) and library-author recipe.\n\n## Documentation\n\n- [Getting Started Guide](docs/getting-started.md) - Installation and first steps\n- [Bootstrapping from source (HEAD)](docs/bootstrap-from-source.md) - Build + install the toolchain and contrib straight from this repo (for consumers tracking HEAD or pre-package); humans and LLMs\n- [Language Tutorial](docs/tutorial.md) - Learn Aether syntax and concepts\n- [Language Reference](docs/language-reference.md) - Complete language specification\n- [Standard Library Reference](docs/stdlib-reference.md) - Full stdlib surface\n- [HTTP Server](docs/http-server.md) - TLS, HTTP/2, middleware, health probes, metrics, graceful shutdown\n- [Reverse Proxy](docs/http-reverse-proxy.md) - `std.http.proxy` upstream pool, load balancing, health, cache, circuit breaker\n- [HTTP Record/Replay (VCR)](docs/http-vcr.md) - moved to the [`servirtium-vcr`](https://github.com/servirtium/servirtium-vcr) monorepo; no longer in the Aether stdlib\n- [Install Layout](docs/install-layout.md) - What ships in `~/.aether`, MANIFEST format, downstream-link contract\n- [C constant import](docs/bindgen-consts.md) - `ae bindgen consts`, C macro constants as Aether consts\n- [Module System](docs/module-system-design.md) - `import`/`exports`, PATH-style `--lib` search chain, selective imports, package layout\n- [Config-IS-Code Diagnostics (`ae help`)](docs/cic-help.md) - Offline heuristic diagnostics for closure-DSL config scripts (Levenshtein, YAML→call form, missing-import suggestions, `--fix`, `--json`, optional `--llm`)\n- [C Interoperability](docs/c-interop.md) - Using C libraries and the `extern` keyword\n- [Embedding Aether in C](docs/c-embedding.md) - Actors inside a C host: runtime init flags, spawn/send from C\n- [Embedding \u0026 emit=lib](docs/emit-lib.md) - Shared-library artifacts, typed SDKs, capability gating, resource caps\n- [Runtime Configuration](docs/runtime-config.md) - Environment variables, profiles, opt-in runtime flags\n- [Architecture Overview](docs/architecture.md) - Runtime and compiler design\n- **Design \u0026 rationale** (why Aether is built the way it is): [closure model](docs/design/closure-lineage-and-runtime-tradeoffs.md), [parse, don't validate](docs/design/parse-dont-validate-review.md), [Aether through Chlipala's lens](docs/design/chlipala-lens.md), [DSL as a rules engine](docs/design/aether-dsl-as-a-rules-engine.md), and concurrency patterns ([sharded actor map](docs/design/sharded-actor-map.md), [snapshot cell](docs/design/snapshot-cell.md), [cache benchmark](docs/design/concurrent-cache-benchmark.md))\n- [Language comparisons](docs/cross-references/) (design history): surveys of Fir, Flint, Zym, and GoogleCloudPlatform/Aether\n- [Memory Management](docs/memory-management.md) - defer-first manual model, arena allocators\n- [Structured Concurrency](docs/structured-concurrency.md) - Proposal: supervision trees + capability-scoped spawn/send (not yet shipped)\n- [Runtime Optimizations](docs/runtime-optimizations.md) - Performance techniques\n- [Cross-Language Benchmarks](benchmarks/cross-language/README.md) - Comparative performance analysis\n- [Docker Setup](docker/README.md) - Container development environment\n\n## Development\n\n### Running Tests\n\n```bash\n# Full CI suite (9 steps, -Werror), runs on your current platform\nmake ci\n\n# Unit tests only (runtime C test suite)\nmake test\n\n# Integration + regression .ae tests\nmake test-ae\n\n# Everything (unit + .ae)\nmake test-all\n\n# Build all example programs\nmake examples\n\n# Full CI + Valgrind + ASan in Docker (Linux)\nmake docker-ci\n```\n\n### Cross-Platform Testing\n\n**CI runs automatically on:** Linux (GCC + Clang), macOS (ARM64 + x86_64), Windows (MinGW/MSYS2)\n\n```bash\n# Cooperative scheduler (no Docker needed)\nmake ci-coop\n\n# Windows cross-compile syntax check (requires mingw-w64 or Docker)\nmake ci-windows              # needs: brew install mingw-w64\nmake docker-ci-windows       # or use Docker\n\n# WebAssembly (requires Docker with Emscripten)\nmake docker-ci-wasm\n\n# ARM embedded syntax check (requires Docker with arm-none-eabi-gcc)\nmake docker-ci-embedded\n\n# All portability checks (coop + WASM + embedded)\nmake ci-portability\n```\n\n**`make ci` tests your current OS only.** No OS can locally test another OS natively, macOS cannot be virtualized on Linux/Windows, Windows build+run requires MSYS2. GitHub Actions CI automatically tests all 5 platform targets (Linux GCC, Linux Clang, macOS ARM64, macOS x86_64, Windows MinGW) on every PR. Docker targets (`docker-ci-windows`, `docker-ci-wasm`, `docker-ci-embedded`) provide cross-compilation syntax checking from any host.\n\nSee [CONTRIBUTING.md](CONTRIBUTING.md) for the full pre-PR checklist.\n\n### Running Benchmarks\n\n```bash\n# Run cross-language benchmark suite with interactive UI\nmake benchmark\n# Open http://localhost:8080 to view results\n\n```\n\nThe benchmark runner is written in Aether (`run_benchmarks.ae`), dogfooding the stdlib. It compiles and runs all 11 languages, parses output, and writes JSON results.\n\n## Sibling Projects\n\nThe Aether ecosystem includes downstream consumers that live in their\nown repos and release independently:\n\n- **[aether-ui](https://github.com/aether-lang-dev/aether-ui)**,\n  Cross-platform widget toolkit (GTK4 on Linux, AppKit on macOS, Win32\n  on Windows) with an AetherUIDriver HTTP test server for headless\n  integration testing. Previously shipped as `contrib/aether_ui/` in\n  this repo; spun out so it can iterate on its own cadence.\n- **[aeb](https://github.com/aether-lang-dev/aeb)**, Build system for\n  multi-package Aether projects. Reads `share/aether/MANIFEST` (the\n  authoritative list of link-suitable runtime/stdlib `.c` files) and\n  dispatches per-package builds with cache reuse and incremental\n  relinking.\n\nIf you're adding to Aether and the change isn't a runtime / compiler /\nstdlib concern, the right home may be one of the siblings above. Both\nrepos consume Aether the same way external users do, `import` against\nthe installed `share/aether/` tree plus `$(ae cflags)` for the link\nline, so they're useful references for downstream integration shapes.\n\n## Status\n\nAether is under active development. The compiler, runtime, and standard library are functional and tested.\n\n## Contributing\n\nContributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.\n\n**Areas of interest:**\n- Runtime optimizations\n- Standard library expansion\n- Documentation and examples\n\n## Supporting Aether\n\nAether is free and open source, built and maintained in personal time. CI runners, cross-platform testing infrastructure, and future project hosting cost real money.\n\nIf Aether is useful to you, consider [sponsoring the project on GitHub](https://github.com/sponsors/nicolas-maman). Every contribution goes directly into development and infrastructure.\n\n[![Sponsor](https://img.shields.io/badge/Sponsor-Aether-blue?logo=github-sponsors)](https://github.com/sponsors/nicolas-maman)\n\n## Acknowledgments\n\nAether's main lineage is:\n\n- **Erlang/OTP**, actor model, message passing, receive-pattern syntax, and\n  \"let it be isolated behind a mailbox\" concurrency.\n- **Go**, pragmatic tooling, simple syntax, explicit `(value, err)` returns,\n  and stdlib surfaces that favor direct operational code over framework magic.\n- **Rust**, systems-programming discipline, explicit capability boundaries,\n  zero-cost lowering goals, and careful ownership/lifetime thinking without\n  adopting a borrow checker.\n- **Pony**, actor-oriented type-safety ideas and the object-capability framing\n  behind sandboxed imports, lexical `hide` / `seal`, and explicit grants.\n- **Smalltalk / Ruby / Groovy**, block and closure ergonomics: trailing-block\n  builders, `do |x| ... end`-style readability, and DSL-shaped APIs where the\n  closure is the configuration.\n\nSmaller facets are deliberately borrowed or adapted from elsewhere:\n\n- **Elixir / Erlang lists**, for `*StringSeq`: O(1) head/tail/cons/length,\n  structural sharing, and pattern matching with `[h | t]`.\n- **Odin**, for struct field injection via `using embed: Sub` while omitting\n  Odin's broader `using` statement form.\n- **Nim / Pony**, for nominal wrapper and move-only-style ideas in features\n  such as distinct types and isolated actor-message payloads.\n- **V**, for compact systems-language ergonomics and some C-adjacent syntax\n  choices in declarations, modules, and direct standard-library APIs.\n- **Ruby**, for heredoc dedent rules in the `\u003c\u003cMARKER ... MARKER` syntax.\n- **Go's standard library**, for concrete API semantics such as\n  `filepath.Clean` / `filepath.Rel`-style path helpers and proxy environment\n  handling compatible with `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY`.\n- **Java, gVisor, WASI, Deno, and FreeBSD Capsicum**, as comparison points and\n  partial prior art for sandboxing, syscall boundaries, and capability-style\n  containment.\n- **HCL, Helm, Pulumi, CDK, and YAML ecosystems**, as the configuration systems\n  Aether's trailing-block \"config is code\" style is intentionally designed to\n  replace for programmable server-shaped libraries.\n- **Rust macros, jOOQ, and RSpec**, as reference points for what Aether's\n  trailing-block DSLs can express directly without a macro or code-generation\n  layer.\n\n## License\n\nMIT License. See [LICENSE](LICENSE) for details.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Faether-lang-dev%2Faether","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Faether-lang-dev%2Faether","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Faether-lang-dev%2Faether/lists"}