Research notes
Axis explores a design pattern: keep a semantic “meaning layer” deliberately tiny, then push platform-specific complexity into bridges. The hope is to make reasoning, transformation, and translation more reliable.
Architecture in one picture
A simplified diagram of the three layers Axis separates: surface → core → bridges.
┌───────────────────────────────────────────────────────────────┐
│ SURFACE LAYERS │
│ (Python, Rust, JS, SQL, CSS, UI logic, config, workflows...) │
│ │
│ • Human-friendly syntax │
│ • Frameworks, libraries, domains │
│ • What developers write today │
│ │
│ These all compile or translate INTO the Axis Semantic Core. │
└───────────────────────────────────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────────────────┐
│ AXIS SEMANTIC CORE │
│ (The minimal meta-language: pure, explicit, stable) │
│ │
│ • Immutable data structures │
│ • Pure functions │
│ • Branching and composition │
│ • No loops, no mutation, no hidden behaviour │
│ • Uniform representation for ALL domains │
│ │
│ This layer contains ALMOST NO RUNTIME COMPLEXITY. │
│ Its job is to capture the *meaning* of programs. │
└───────────────────────────────────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────────────────┐
│ BRIDGE LAYERS │
│ (Runtime integration: Python, Rust, OS, DB, GPU, etc.) │
│ │
│ • Handles IO, files, sockets │
│ • Handles floats, number semantics │
│ • Handles concurrency, blocking, async │
│ • Calls out to OS, GPU, DB engines │
│ • Implements foreign functions in real systems │
│ │
│ Complexity moves *down* into bridges so the Core stays clean. │
└───────────────────────────────────────────────────────────────┘
Three core commitments
Small meaning-model
The semantic core aims to include only the minimum needed to represent meaning: immutable values, records, lists, pure functions, application, and branching.
Immutable semantics
The function registry proposes that once a function is published, its behaviour does not change. Versioning becomes additive: new meaning is a new function, not a rewrite.
Reality below the line
OS details, float edge cases, concurrency, file/network IO, GPUs and databases live in bridges. Bridges are hard — but concentrating that work makes the upper layers simpler and more stable.
Deterministic pipelines
Axis is motivated by the observation that tools (including AI) behave better when ambiguity is removed and transformations are explicit and deterministic.
Where this might go (and where it actually is)
Axis is early. Many ideas are still “notes and examples,” not end-to-end working systems. That is intentional: the research is to find the smallest set of constraints that still makes useful tools possible.
We are a long way from “universal anything.” The short-term plan is pragmatic: finish the core spec, build a first interpreter (Python first), implement one minimal bridge, then run real examples.
If you want to engage with the details, the documents page links to the current deep dives.