Xe/olin
61.5
Adequate · 8 November 2026
2.8k
lines of production code
Go
with Zig, Rust, JavaScript
7
measurements over time
What this system is
Features
Add CWA command-line tool for running WebAssembly modules
Introduces the cmd/cwa executable, a command-line interface for executing WebAssembly modules. The tool supports running both standard CWA modules and Go-compiled WebAssembly binaries, with configurable memory limits, gas-based execution limits, and policy-driven resource constraints. It also provides detailed VM statistics and timing information, and includes a test suite that validates the tool's behavior against sample WebAssembly files.
cmd/cwa · high confidence
Add CommonWA, Dagger, and WasmGo ABI implementations
The \abi\ package now includes three distinct ABI implementations for WebAssembly modules: CommonWA (cwa), which provides a process model with environment variables, logging, and resource handling; Dagger, which offers a file-descriptor-based API for reading, writing, and syncing files; and WasmGo, which bridges Go's WebAssembly runtime with the CommonWA process model, exposing JavaScript-like objects and file system constants. These additions expand the range of WebAssembly modules the system can execute by providing specific interfaces for each target environment.
abi · high confidence
Add HTTP client and core runtime modules
The Olin library now includes a new HTTP client implementation in \src/http/client.rs\, which handles serializing HTTP requests and parsing responses using the \http\ and \httparse\ crates. Additionally, core runtime modules have been added to \src/lib.rs\, including \log\ for logging, \env\ for environment variables, \sys\ for low-level FFI bindings, and \panic\ for custom panic handling. A new binary \allyourlogs.rs\ was also added to demonstrate logging capabilities.
rust/olin · high confidence
Add Olin runtime library in Zig
The Olin runtime library is introduced in Zig, providing a set of modules for system-level operations. This includes file and resource management (resource.zig), environment variable access (env.zig), error handling (error.zig), HTTP status codes (http/status\_codes.zig), and logging (log.zig). The library also provides utilities for random number generation (random.zig), time (time.zig), startup arguments (startup.zig), and process control (runtime.zig). A CGI-like interface (cwagi.zig) is also included, allowing for web application development within the Olin framework.
zig/src/olin · high confidence
Add Rust-based CWA gateway implementation
A new Rust implementation for the Common WebAssembly API (CWA) gateway has been added. This component handles HTTP requests by reading environment variables (REQUEST\_METHOD, PATH\_INFO, RUN\_ID, WORKER\_ID) and startup arguments, then returning a text/plain response. The gateway routes requests to /cadey with a specific message, while all other paths return detailed runtime information including the WebAssembly runtime version, current time, and environment details.
rust/cwagi · high confidence
Add Rust-based CWA implementation and build infrastructure
Introduces a new Rust implementation for the CommonWA (CWA) specification, including build scripts for the core library (olin), the CWA agent (cwagi), and tests. The setup configures the Rust toolchain to target wasm32-unknown-unknown and includes necessary configuration files (.cargo/config, .gitignore, .dockerignore) to support building and running the Rust components.
rust · high confidence
Add Zig-based WebAssembly examples and utilities
The repository now includes a collection of Zig source files in the \zig/src\ directory, providing a suite of WebAssembly examples and utilities. These include a Common WebAssembly Interface (CWA) entry point (\allyourargs.zig\), a base case (\allyourbase.zig\), logging tests (\allyourlogs.zig\), a file concatenation tool (\cat.zig\), a comprehensive runtime test suite (\coi.zig\), a Common WebAssembly Application Gateway Interface (CWAGI) HTTP handler (\cwagi.zig\), exit code demonstrations (\exit0.zig\, \exit1.zig\), an HTTP test client (\httptest.zig\), a crash test (\mincrash.zig\), a runtime metadata printer (\runtime\_name.zig\), a terminal-based rasterizer (\triangle.zig\), and a binary asset (\shaman.aa\ with its loader \shaman.zig\).
zig/src · high confidence
Add Zig-based WebAssembly examples with resource policies
The repository now includes a new set of WebAssembly examples implemented in Zig, including utilities like 'cat', 'httptest', and 'triangle'. Each example is accompanied by a corresponding .policy file that defines specific resource constraints, such as 'ram-page-limit' and 'gas-limit', ensuring predictable execution limits. A build script automates the compilation of these Zig sources into WebAssembly modules, and a test script validates their behavior using the 'cwa' runtime.
zig · high confidence
Added Nix build environment for Zig 0.6.0
The project now includes Nix build infrastructure to manage dependencies and compile the Zig compiler. This introduces a new \nix/zig.nix\ module that builds the Zig 0.6.0 release from the official binary distribution, alongside a \nix/deps.nix\ file that defines Go dependencies for the build process. These changes establish the foundation for building the project using the Nix package manager.
nix · high confidence
Added runtime support files for executing WebAssembly components
The 'run' directory now includes essential files to execute the application's WebAssembly modules. This adds a shell script (run.sh) to launch the CWA CGI binary, a JavaScript bridge (wasm\_exec.js) to handle Go/WASM runtime interactions in browser and Node.js environments, and an Emacs major mode configuration for editing policy files. These changes enable the actual runtime execution of the compiled WASM binaries.
run · high confidence
Initial release of Olin: a WebAssembly runtime and CLI tool
Olin is introduced as a runtime environment for WebAssembly, designed to wrap Wasm with functions to access the outside world and track metrics like instruction counts, syscalls, and memory usage for profiling purposes. The release includes support for the Common WebAssembly (CWA) specification and Go's WebAssembly ABI, alongside a Dockerfile for building the runtime and a Nix build file for the \cwa\ and \cwa-cgi\ binaries. The project also provides a CLI tool (\cwa\) and CGI helper (\cwa-cgi\) for running WebAssembly modules.
(repo-wide) · high confidence
Introduce cwa-cgi service with HTTP and Prometheus metrics support
A new Go-based HTTP server (cmd/cwa-cgi/main.go) is introduced to serve CWA modules over HTTP. It runs a CGI handler for the WASM binary and exposes a /metrics endpoint for Prometheus monitoring, alongside a /reboot endpoint for process management.
cmd/cwa-cgi · high confidence
Introduce file resolver and name generator utilities
Added the \fileresolver\ package providing various file-like abstractions for the Olin project, including HTTP transport, OS file descriptors, logging, null/zero/reader/writer wrappers, and random data sources. Also added the \namegen\ package, which generates random names based on tarot card ranks and suits. Both packages include corresponding test files to verify their behavior.
fileresolver, namegen · high confidence
Introduce innative-runtime as a Go-based runtime environment
Added the \cmd/innative-runtime\ package, which provides a Go implementation of a runtime environment for executing WebAssembly modules. This includes a main entry point that initializes a virtual machine and exposes various environment functions (such as logging, environment variable access, resource management, and random number generation) to support the execution of compiled code.
cmd/innative-runtime · high confidence
Introduce policy configuration for allowed and disallowed URLs
A new policy module has been added to the codebase, allowing users to define URL access rules via configuration files. The policy system parses allow and disallow lists of URL patterns, along with resource limits for RAM pages and gas instructions, enabling fine-grained control over which external resources can be accessed and the computational budget for operations.
policy · high confidence
Behavioural changes
Added CGI environment variable derivation
The cgi package now includes a new env.go file that provides a DeriveEnv function. This function constructs a map of environment variables from an HTTP request, including standard CGI fields like REQUEST\_METHOD, PATH\_INFO, and QUERY\_STRING, as well as custom RUN\_ID and WORKER\ID. It also iterates over HTTP headers to populate HTTP\\* environment variables, excluding any header named 'PROXY'.
cgi · medium confidence
Test coverage
Added Rust test suite for the Olin runtime
Added a new Rust test suite in the \rust/tests\ directory to verify the functionality of the Olin runtime. The suite includes tests for environment variables, random number generation, resource handling, runtime information, startup arguments, standard I/O, and time. It also includes regression tests for specific issues (22, 37, 39) and tests for various URL schemes (HTTP, LOG, NULL, RANDOM, ZERO).
rust/tests · high confidence
Dependencies
Initial release of Olin and CWAGI Rust crates
The Olin and CWAGI Rust crates are introduced, establishing the project's Rust-based runtime and library components. The Olin crate (v0.2.0) provides a small runtime library for programs targeting Olin, including binaries like 'shaman' and 'allyourlogs'. The CWAGI crate (v0.1.0) depends on Olin. Both crates are configured with specific dependencies such as 'chrono', 'http', and 'httparse', with their respective Cargo.lock files generated to pin exact versions.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 58 → 62 (+3.7)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 77 → 77 (+0.0)
- Architecture 95 → 95 (+0.0)
- Maturity 49 → 57 (+7.2)
- Readiness 54 → 54 (+0.0)
- Security 64 → 69 (+5.4)
- Performance 100 → 100 (+0.0)
Resolved (4)
- Inconsistent return types for buffer-based argument retrieval. arg_os_at_buf returns Option (implying the argument might not exist or be valid), while arg_at_buf returns str directly (implying it always succeeds or panics on failure). This inconsistency makes error handling unpredictable for the user.
- Inconsistent return types for capacity-based argument retrieval. arg_os_at returns a single u8 (likely a byte or error code?), while arg_at returns a String. The naming 'os_at' vs 'at' is unclear, and the return types do not match the intent of retrieving an argument string.
- Members sharing a duplicated core (4 members, 50+ identical tokens) (abi/wasmgo/abi.go)
- Redundant methods for retrieving the runtime name. One takes a mutable buffer (likely for zero-allocation efficiency) and the other returns a String (heap-allocated). While this pattern exists elsewhere (e.g., startup.arg_at vs arg_at_buf), having both for the same simple string retrieval without clear documentation on when to use which creates API surface bloat.
New (1)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (abi/wasmgo/abi.go)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
Xe/olin was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 0cf90810960ba4d7d80e20448ec08a71a3510deb — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.