axonos.org  ·  Engineering notes  ·  connect@axonos.org

This is the founder, demo, and community surface for AxonOS. The canonical engineering source of truth is the AxonOS-org organisation. Every quantitative performance and validation claim is governed by one file — axonos-standard/CLAIMS.md — which records, for each figure, its evidence level, the artefact it is re-derived from, and the finding that would falsify it.

AxonOS is a hard real-time operating system for brain–computer interfaces — the layer between the silicon and the application, where neither Linux nor a stock RTOS can hold the jitter and latency a closed neural loop demands. Written in Rust, #![no_std], for ARM Cortex-M.

The figures below are analytical bounds, proven with Kani and derived from datasheet cycle counts — not measurements. On-hardware validation is pre-registered and publication-pending in axonos-validation; no measured number is claimed until its raw trace is published. They are encoded the same way they are enforced — in code.

#![no_std]
#![forbid(unsafe_code)]

//! AxonOS — a deterministic, hard real-time OS for brain–computer interfaces.
//! The layer between silicon and intent.

/// Deadlines are biological, not arbitrary.
pub enum Schedule {
    EarliestDeadlineFirst,
}

/// Consent is enforced at Layer 2 (Connection) — below the coupling engine —
/// so no higher cognitive layer can override a withdrawal. `Withdrawn` is terminal.
pub enum Consent {
    Granted,
    Suspended,
    Withdrawn,
}

/// The real-time contract, held on every cycle of the dual-core pipeline.
pub struct Kernel;

impl Kernel {
    // Current reference bring-up; the firmware crate boots here.
    pub const TARGET_CURRENT: &'static str = "thumbv7em-none-eabihf"; // Cortex-M4F · STM32F407
    // Documented next target for the secure Cognitive Hypervisor.
    pub const TARGET_NEXT:    &'static str = "thumbv8m.main-none-eabihf"; // Cortex-M33 + TrustZone-M · STM32H573
    pub const SCHEDULE:       Schedule     = Schedule::EarliestDeadlineFirst;
    pub const WCRT_NS:        u32          = 972_000; // L1 analytical bound (Liu–Layland EDF), inside a 4 ms deadline
    pub const JITTER_NS:      u32          = 2_100;   // σ, derived; on-hardware L2 trace publication-pending
    pub const HEAP_ON_PATH:   bool         = false;   // zero-copy DMA into a static slab arena
}

/// The kernel exposes exactly one typed, capability-gated event stream.
pub trait IntentStream {
    fn poll(&mut self) -> Option<Observation>;
    fn consent(&self) -> Consent;
}

_{Evidence levels (L1 formally proven · L2 measured on reference hardware · L3 independently validated) and the falsifiability of each figure are defined in axonos-standard/VALIDATION.md and catalogued in CLAIMS.md. The peer-readable derivation is the Zenodo preprint — analytical, falsifiable, no measurement claims.}

The kernel emits a single 32-byte intent record. Every binding decodes it byte-for-byte identically — the wire format is the contract, cross-checked across Rust, Python, C, JavaScript, and Java in axonos-conformance.

use axonos_sdk::{Capability, IntentKind, IntentStream, Manifest};

let manifest = Manifest::builder()
    .app_id("org.axonos.cursor")?
    .capability(Capability::Navigation)   // kernel caps delivery at 50 Hz
    .max_rate_hz(50)
    .build()?;

let mut stream = IntentStream::connect(&manifest)?; // ABI handshake, then data flows
while let Some(obs) = stream.poll() {
    if let IntentKind::Direction(dir) = obs.kind() {
        cursor.step(dir, obs.confidence_raw());       // u16 Q0.16 — exact, never a float
    }
}

The kernel and everything it contracts with. Every quantitative claim across these repositories is re-derived from an artefact and catalogued in CLAIMS.md; nothing here is asserted without a falsifiable source.

_{Evidence levels — L1 formally proven (Kani / analytical bound) · L2 measured on reference hardware · L3 independently validated. The mapping from every published figure to its evidence level and its falsifier is the single source of truth in CLAIMS.md.}

The fastest way to judge any of this is not to read it.

# the whole chain from a seed: electrode -> privacy vault -> the right to act
git clone https://github.com/AxonOS-org/axonos-stack && cd axonos-stack
cargo run --locked --bin session -- --seed 7 --frames 3000 | diff - reference/session-7.txt

Silence means it reproduced byte for byte on your machine. The session is not a happy path: an electrode lifts at 4.8 s and the transcript records the system withdrawing the right to actuate 96 ms later, while continuing to record — because the moments a device stops trusting itself are the ones a clinician needs afterwards. Its last line is an accounting identity, delivered + lost = produced, and if it ever fails one of the three components is lying about what it saw.

Then check who wrote the automated commits on the live map, and whether GitHub signed them:

gh api repos/AxonOS-BCI/axonos-community-radar/commits \
  --jq '.[0:10][] | "\(.commit.verification.verified)  \(.author.login)"'

That one is here because it recently read false. The scanner published through a personal token, and GitHub signs API-created commits only for app identities — so the public map's history was unsigned for six weeks. The fix was to stop the token writing at all: the scanner now hands the payload over as a release asset, which creates no commit, and this repository's own workflow commits it with the identity that is signed. The command stays in this README because a claim that was wrong once is worth leaving checkable.

The other half of one organism: AxonOS-org holds the law and the running core; this account holds its senses — the community radar, a living, scored map of the whole open-BCI field — and its skin, the playable demos below. The full anatomy →

Repository	Activity	What it is
neural-boundary-game		Canonical interactive demo. Deterministic Rust/WASM model of the AxonOS sovereignty architecture — consent, least-privilege scopes, sealed privacy vault, StimGuard — playable in-browser, byte-for-byte replayable. The demo embedded on axonos.org.
axonos-boundary-run-v64		Latest pure-JS browser game — The Sovereign Signal. Zero-telemetry cognitive-boundary simulator with a deterministic, independently verifiable SHA-256 replay proof, re-checked in CI in both JavaScript and Python.

_{Earlier game iterations — axonos-boundary-run-v9, axonos-boundary-run-v52, neural-boundary-game-play — are kept as historical references and are being archived in favour of the two demos above. Engineering is documented end to end in the AxonOS notes.}

Everything above — the radar, the games, the OS — is free and open: no paywalls, no ads, no tracking, no tokens. If this work is useful to you, a voluntary Dogecoin tip is the direct way to fuel it. One ecosystem, one address:

_{Contributions are voluntary — not purchases, not investments, no product entitlement. Commercial licensing is a separate written-agreement channel (fiat default): connect@axonos.org. Full terms: CRYPTO_PAYMENT_TERMS.md.}