Skip to main content

Crate gresil

Crate gresil 

Source
Expand description

§gresil

no_std, i16 fixed-point spiking neural networks for edge and RISC-V silicon — LIF neurons, CSR synapses, a ternary weight quantizer, an AVX2 batch kernel, and, behind unstable features, pairwise STDP, the ternary bridge codecs and the freezer.

Published on crates.io as gresil from 0.1.0-alpha.9; alpha.8 and earlier as neuralos-snn (AGPL-3.0-or-later).

§What this crate is

A spiking-neural-network substrate: the neuron/synapse/network core you can run bare-metal. Integer-only hot path (an i16 membrane on the mV or centi-mV grid, an i16 current in pA, u32 microseconds at the neuron; the networks keep a u64 clock) — no floating point, no allocator in the core, no_std by default. Designed for FPU-less edge targets (ESP32-C3, HiFive, QEMU riscv64gc) and validated against the IEEE 2025 “Full-Integer SNN Inference with RISC-V ISA” design axis.

§Quick start

One LIF neuron on the centi-mV grid, driven by a constant 160 pA at a 1 ms step. It is the neuron firmware/esp32c3 runs on the ESP32-C3, and the asserts are what the board prints over serial: 147 spikes, first spike step 55. Those come from the firmware’s burst arm, where simulated time advances exactly 1 ms a step, so the board and the host agree spike for spike — the captures are in evidence/esp32c3-bringup/README.md.

use gresil::{LIFNeuron, NeuronType, VoltageResolution};

let mut neuron = LIFNeuron::new(
    0,
    NeuronType::Excitatory,
    VoltageResolution::CentiMillivolt,
);

let mut spikes = 0u32;
let mut first_spike_step = None;

for step in 0..10_000u32 {
    neuron.decay_adaptation_current();
    if neuron.integrate_and_fire(
        160,          // input current, pA
        1_000,        // time step, µs
        step * 1_000, // simulation time, µs
    ) {
        spikes += 1;
        first_spike_step.get_or_insert(step);
    }
}

assert_eq!(spikes, 147);
assert_eq!(first_spike_step, Some(55));

Every item in it is no_std, so the same code runs on the host and on the chip.

The firmware’s real-time loop is a second arm, paced by the wall clock. Its neuron has the constructor’s noise, 0, as the burst arm’s does, so its first spike is step 55 as well, and only the microseconds it prints vary between runs (the version notes below, written while the neuron still had noise, print a loop’s first spike at step 56). The assert here is the burst’s 55.

§Modules

Every item’s home is its module; the crate root re-exports only the names a first program writes, and every example in these docs imports each name by its shortest public path.

ModuleWhat it holds
lif_neuronLeaky-Integrate-and-Fire neuron, fixed-point, per-neuron voltage grid (VoltageResolution: mV or centi-mV, written at construction)
spike_recorderSpikeRecorder, the spike history a caller keeps when it wants one: a [u32; MAX_SPIKE_HISTORY] ring (64 entries, the oldest overwritten), fed from integrate_and_fire’s return; the neuron keeps none
synapseSynapse, weight scale SCALE = 1000; with unstable-stdp, the pairwise STDP rule (a₊ 50 / a₋ −53 / lr 100)
network (std)SpikingNeuralNetwork orchestration (step()), a CSR synapse store (forward and reverse), 4 topology builders (Random, Small-World, Feedforward, Balanced E/I), per-step stats; with unstable-stdp, the plasticity passes (LTD + LTP), off until set_plasticity_enabled(true)
fixedFixedNetwork<N, S>: N neurons and S synapses in arrays, no heap, no plasticity, the std step’s order; its step has no Result, no index and no division of its own. TryFrom<&SpikingNeuralNetwork> (std) converts a plasticity-off network of the same size; with unstable-freeze (std), fixed::freeze, the freezer, which writes a network as the Rust source of the arrays a FixedNetwork steps
traceneuralos-trace v1, the trace format a host and a board write alike: its spec, row (one row, to any core::fmt::Write) and, with std, header (the header line, from a network); Kind and Rows, two of its fields
tritTernary weight type {-1, 0, +1} + scale, ternarizer; with unstable-stdp, the stochastic bucket-flip (LFSR, integer-only)
bridge (feature)BitNet i2_s encode/decode (bit-exact round-trip), Prism q1_0/q2_0 import + q2_0 export, integer fp16 widening — layouts pinned from reference sources, loud errors on impossible input
nirNIR (Neuromorphic Intermediate Representation) slice 1 — JSON import/export of Input/Linear/LIF/Output graphs, explicit per-node quantization records, loud lossiness, byte-stable export. Schema pinned verbatim to the reference implementation (neuromorphs/NIR @ 7883c3c); fixtures are the reference’s own emissions (tools/gen_nir_fixtures.py)
kernel (feature)Shared no_std ternary matvec: sequential 2-bit packed trits × Q15 activations → i32, absmax normalization, wire→compute repack seam
simd (feature)AVX2 batch LIF integration (x86_64, ~1.6–2.2× vs scalar, ±2 mV tolerance)

§The voltage grid story

delta_v = dt_over_tau · (leak + R·I·s/1000) / 1000 truncates to whole quanta, s the grid’s scale (1 on mV, 100 on centi-mV). On the mV grid, which SpikingNeuralNetwork::new builds on, a steady sub-threshold current at rest inside the dead zone (at a 1 ms step, ~200 pA for its excitatory neurons, ~100 pA for its inhibitory ones) moves the membrane exactly zero — recorded, tested, and the reason VoltageResolution::CentiMillivolt exists (100× finer dead zone, same i16, bit-identical arithmetic shape). The network’s mV grid keeps every historically recorded result bit-exact.

§Features

  • std (default) — enables the network orchestration module
  • simd — implies std; the AVX2 batch LIF kernel on x86_64, the scalar reference on any other target
  • unstable-stdp — STDP: STDPRule, Synapse::update_weight, SpikingNeuralNetwork::set_plasticity_enabled, SpikingNeuralNetwork::stochastic_ternary_step, trit::stochastic_ternary_flip, trit::STOCHASTIC_FLIP_RATE, and STDP’s instruments: Synapse‘s min_weight(), max_weight(), raw_stdp_delta() and absorbed_delta(), and NetworkStats’ plasticity_events and three stdp_pairs_*. Works with and without std.
  • unstable-bridge — the closed ternary bridge chapter: the bridge codecs (i2_s, q1_0, q2_0) and the kernel matvec. Works with and without std.
  • unstable-freeze — the freezer, fixed::freeze: a network written as the Rust source of the arrays a FixedNetwork steps, what gresil-nir2json --freeze writes. std only: without std the feature builds nothing.

“Unstable” means one thing: anything behind an unstable- feature may change or go in a minor release. It is outside the semver promise, and the rest of the crate is inside it. A default build does not learn: a network starts with plasticity off, and only set_plasticity_enabled, behind unstable-stdp, turns it on. The getter plasticity_enabled() is stable and reads false without the feature; STDP’s instruments are behind it.

Without std the crate builds no_std (neurons, the spike recorder, synapses, the fixed network, the trace rows, trit, nir, and with unstable-bridge the bridge and the kernel) — the embedded posture CI enforces.

§Usage sketch

use gresil::{NetworkTopology, SpikingNeuralNetwork, VoltageResolution};

fn main() -> gresil::Result<()> {
    let mut net = SpikingNeuralNetwork::new_with_voltage_resolution(
        128,
        1_000,
        NetworkTopology::Balanced {
            excitatory_ratio: 0.8,
        },
        VoltageResolution::Millivolt,
    )?;
    net.build_topology()?;

    let inputs = [0i16; 128];
    for _ in 0..100 {
        // decay → integrate → clear → propagate; the step returns its
        // `Vec<Spike>`. Weights stay fixed: a default build does not learn
        // (§ Features, `unstable-stdp`)
        let _spikes = net.step(&inputs)?;
    }
    Ok(())
}

§Anti-scope

No I/O, no persistence, no UI, no drivers, no “OS”, no crypto, no LLM runtime — the library is a library. (The research runtime that proved a ternary SNN↔LLM bridge on this substrate lives in the workspace’s neuralos-rt, publish = false.)

§Since alpha.2

  • F1 — adaptation-decay contract pinned: unit tests pin the exact −1/step decay with floor 0 and the +2/spike jump; a 6,000-step live test proves a driven net stays firing and adaptation equilibrates. Leak convergence pinned too (dt = τ lands on rest exactly, both directions).
  • The coupling knob — synaptic_input_divisor (new API): the recurrent pulse is weight / divisor μA. Default 10 = the historical pulse byte-for-byte; 0 rejected; pinned by default + doubling tests.
  • network.rs split into csr.rs + stats.rs — every published path unchanged, CSR build/equivalence now pinned by dedicated tests (unsorted insertion, external adds, reverse-CSR incoming, plasticity weight sync).
  • F5a — the DECORATIVE-in-orchestration machinery removed (alpha semver window): Synapse’s transmission/eligibility state (delay_us, conductance, transmission_buffer, eligibility_trace, recent_activity, synapse-side last_spike_time_us) and its dead methods (transmit, receive_spike, is_active, set_delay_us, reset), plus LIFNeuron::tau_synapse_us. Orchestration never read any of it — proven output-neutral by byte-exact re-pins of the bridge examples (gate verdict, export sha, 13/13 null patches).
  • Pub-API census: five module-internal fns de-pubbed (LIFNeuron::new_with_type, set_voltage_resolution, the three i2_s layout helpers); introspection accessors and builders stay pub — see the alpha.3 audit record in the repo’s ISA.md.
  • SIMD gate runs in CI; the batch kernel is documented mV-grid-only.

§Since alpha.8 (the alpha.9 notes)

  • The crate is gresil, which neuralos-snn was: use gresil:: where you wrote use neuralos_snn::.
  • The pub walk (what stops being public before 0.1.0 promises the surface): the root keeps ten names, the neuron and the synapse have no public field, each refusal returns the variant of its rule, the current is named in pA (the older notes below say μA for the same numbers), STDP and the closed bridge chapter sit behind unstable features, and a network does not learn unless asked.
  • NIR imports at true scale, a two-layer graph builds, and a stranger’s .nir reaches the ESP32-C3 in one command.
  • Every break with its fix, by module, and the board’s figures: the release notes.

§Since alpha.7 (the alpha.8 notes)

  • FixedNetwork<N, S>, no_std: N neurons and S synapses in arrays, no heap, no plasticity, the std network’s step in the same order; its step has no Result, no index and no division of its own. FixedNetwork::try_from(&net) converts a plasticity-off SpikingNeuralNetwork of the same size on the host. No panic path in its step, proven at link time (the repository’s proofs/no-panic-step/: a panic handler that is an undefined symbol, under the firmware’s profile and under one without cross-crate LTO; the one path the proof found, a division in dt_over_tau’s wide half, now divides by a NonZero, behavior identical).
  • Traces: tests/traces/, thirteen cases of the network as text (neuralos-trace v1: the spikes and every membrane, step by step), compared by cargo test against the code; a trace that moves is red at its line. A reference vector pins the bare neuron against an i128 model on 150 rows.
  • The spike ring leaves the neuron. LIFNeuron keeps no history; SpikeRecorder, a no_std 64-entry ring the caller feeds from integrate_and_fire’s return, holds it, with the crate-private firing-rate and ISI readers. size_of::<LIFNeuron>() is 44 bytes (320 on alpha.7, x86-64), pinned by a test on the host (x86-64); the same 44 on riscv32imc was read at PR D (#28), not asserted in the tree. API: the one public path that moved is MAX_SPIKE_HISTORY, at the crate root and in spike_recorder, no longer under lif_neuron; the neuron’s history readers were not public in alpha.7 and are not now; they live on the recorder.
  • The MSRV is tested. rust-version = "1.92", checked on 1.92.0 in CI in three configurations (std, no_std, simd); the toolchain pin is 1.98.1.
  • On the ESP32-C3 (rv32imc, 160 MHz), the same board: every plasticity-off trace of tests/traces/, twelve of the thirteen, replays on the chip bit for bit from the arrays the host steps, the spikes and every membrane, row for row (plasticity-on is outside FixedNetwork by design). The frozen feedforward-8 (8 neurons, 6 synapses) steps in 14,058 ns per step of the whole network, its spike tally included; the neuron as a network holds it 1,576 ns/step (1,579 on alpha.7). Every behavior figure of alpha.7 is unchanged: 147 spikes in the 10,000-step burst, the first at step 55, the same checksum. Numbers, logs and .text pins: evidence/esp32c3-bringup/README.md § Sixth and § Seventh entry.
  • On x86-64 the host spike-path bench is within a nanosecond per step of alpha.7 on the same compiler (forced −0.6, control +0.05 ns/step, one run): evidence/esp32c3-bringup/README.md § Host bench, round 33.
  • Under QEMU riscv64gc the same twelve traces replay bit for bit (proofs/qemu-trace-replay/, evidence/qemu-riscv-gate/).
  • The road to 0.1.0 is the repository’s docs/ROADMAP.md § 0.1.0: fourteen checks a stranger can run, six of them holding at this release.

§Since alpha.6 (the alpha.7 notes)

  • Both divisions by 1000 in integrate_and_fire narrow to i32 when the value fits (private div_1000): the same truncating division of the same value, a multiply-high by the constant on a 32-bit core instead of a call to a software 64-bit division; a value that does not fit takes the i64 division as before, out of line. Exact by construction, pinned by a proptest against x / 1000 in i64 (half its draws in i32, half in all of i64) and a unit test on both sides of the guard; the two i128 exactness proofs of integrate_and_fire are unchanged and green.
  • dt_over_tau computes in u32 when dt_us <= u32::MAX / 1000 (4,294,967 µs): one hardware divide on a 32-bit core; above it, the u64 formula as before. The same results over the whole u32 × u32 domain, pinned the same way.
  • The spike ring indexes its two stores with a mask (& (MAX_SPIKE_HISTORY - 1), the power of two asserted at compile time): the same slots, and a bound the optimizer can see in the index. On the ESP32-C3 the bounds check on the bare index was what kept the neuron out of registers.
  • #[inline] on LIFNeuron::integrate_and_fire, a hint: without it one of the firmware’s call sites stepped the neuron out of line.
  • On the ESP32-C3 (rv32imc, 160 MHz), same board and same firmware source, the firmware now times two bursts. The neuron as a network holds it (in memory, dt at run time) costs 1,579 ns per step, against 3,878 on alpha.6; the burst the compiler can see through costs 563, against 2,863. Every behavior figure is identical: 147 spikes in the 10,000-step burst, the first at step 55, the same checksum of the spike steps; the real-time loop’s first spike still at step 56. No 64-bit software division is left in the step. The 2,842 of the alpha.6 notes below is the second burst’s shape on alpha.6, measured before the checksum code existed; a network’s run-time dt cost more, 3,878. Mechanism, listings and pins: evidence/esp32c3-bringup/README.md § Third entry (ISA round 27).
  • On x86-64 the host spike-path bench is about 2 to 2.5 ns per step slower (+22 to 26 %), bisected across the round’s commits and recorded, not fixed (the principal’s ruling): the chip is the target. evidence/esp32c3-bringup/README.md § Host bench, round 27.

§Since alpha.5 (the alpha.6 notes)

  • Spike history is a [u32; MAX_SPIKE_HISTORY] ring (private SpikeRing in lif_neuron.rs): O(1) push, the oldest entry overwritten once full, iteration oldest to newest. It replaces heapless::Vec, whose remove(0) shifted the whole buffer on every spike past the 64th. Proven by a differential proptest against the pre-ring implementation kept verbatim as the oracle (same spike times, same order, same three consumers), a proptest on the ring alone, and two unit pins (Debug shows live entries only; indexing past len panics like a slice). No public API moved.
  • No runtime dependencies. heapless is a dev-dependency now (the oracle above); cargo tree -e normal prints the crate alone. The crate depends on core.
  • rust-version = "1.92" declared, inherited from the workspace; it is the toolchain pin, the only MSRV anyone has verified.
  • isi_stats_us sums in u128 (test-gated, zero non-test callers): with u64 accumulators, three intervals above 2^32/√3 (about 2.48e9 µs, reachable through the non-monotonic filter) overflowed the sum of squares. Found by the differential proptest on 2026-09-10; that test now runs on arbitrary u32 times, and a unit test pins three maximal intervals on both sides.
  • On the ESP32-C3 (rv32imc, 160 MHz) the timed burst costs 2,842 ns per neuron step with this version, against 1,501 ns measured on alpha.5 with the same firmware source, every behavior figure identical (147 spikes in 10,000 steps, first spike at step 56, 14.7 spikes/s). Read from the two flashed binaries: the alpha.5 burst loop was one the compiler happened to keep in registers, with one 64-bit software division per step; alpha.6’s keeps the neuron in memory and pays two, plus a hardware divu, which is what a Vec<LIFNeuron> network pays on either version. The library did not get slower in the general case; the honest number is the higher one. Mechanism, listings and pins: evidence/esp32c3-bringup/README.md § The mechanism (ISA round-23); narrowing those divisions, bit-exact, is the next brief.

§Since alpha.4 (the alpha.5 notes)

  • General graph assembly — NirImport::build_network: any reference-emitted Input/Linear/LIF/Output graph assembles onto a real SpikingNeuralNetwork and fires. Every LIF population becomes neurons (its own quantized params); every LIF→LIF edge becomes an EDGE_PULSE_QUANTA synapse pair (the ratified D1 contract: 200 → a 20 μA pulse at the default divisor 10, +10 centi-quanta exactly one step later — exact-pinned on both grids, the mV grid dead 10× over, which is why recurrent graphs reject mV options BY NAME with the copy-pasteable re-import remedy); the Linear DAG folds symbolically at setup and quantizes ONCE per (drive Linear, root Input) stage (D2 fusion — no hop-by-hop i16 composition), merged saturating into the global per-step current vector (D5 multi-Input). Plasticity frozen at assembly (NIR has no plasticity term). New public surface: build_network, NirGraphEncoder, NirAssemblyReport, LinearFusedRecord, EDGE_PULSE_QUANTA, and NirError::EdgeShapeMismatch (per-edge reference type-check parity). Every out-of-slice shape is a NAMED rejection (readout, direct drive, encoder-only, self-loop, Output-as-source, Linear cycles, pass-through, empty/no-Input/no-Output, the D7 population bound); Input-unreachable structure assembles with structural UndrivenPopulation notes — silence documented, never silent. The frozen chain is proven bit-exact through both builders (nir_assembly_gate, 6/6, evidence of record).
  • Honest-claim language of record (assembly): structure, per-edge type shapes, and quantization records are exact w.r.t. the pinned document; dynamics are named substrate conventions (EDGE_PULSE_QUANTA, divisor, grid, one-step delay, frozen plasticity) pinned by exact-value tests; the reference defines no execution semantics at this sha.
  • The banked consolidation breaks ride here (2026-08-22): the NeuronBuilder/SynapseBuilder types and the setter surface deleted, the test-only introspection quartet relocated under #[cfg(test)], LIFNeuron::spikes() deleted (zero callers), Synapse::normalized_weight test-relocated — API breaks with no known consumers.

§Since alpha.3 (the alpha.4 notes — PUBLISHED 2026-08-22)

  • NIR slice 1 shipped in alpha.3 (missing from the notes above): neuralos_snn::nir — JSON import/export of Input/Linear/LIF/Output graphs, schema pinned to neuromorphs/NIR@7883c3c, reference-emitted fixtures + nir_format_gate, explicit per-node quantization records.
  • Fresh-eyes review fixes (findings R1-R8): skip_value depth-capped at 64 (adversarial nesting is a loud Json error, not a stack overflow); trailing content after the root rejected (Python json.loads parity); denormal-absmax weights (e.g. 5e-324) are a loud BadNumber — the underflowed scale = 0 would have zeroed exports silently and broken idempotence; round_half_away rewritten as truncate-compare (the classic add-±0.5 idiom misrounds values 1 ulp below a half — reachable via r in MΩ: 499999.99999999994 Ω imported as 1 MΩ); ChainEncoder::encode accumulates in i64 (i32 silently wrapped negative at cols ≥ 3 with full-scale weights); scan rejects 1-D/empty/3-D weight arrays up front; export rejects dangling edge indices (no "?" placeholders).
  • Structured-entry seam (post-review): quantize_linear and quantize_lif are public — callers holding materialized f64 values (HDF5 import, builders) quantize without a JSON document, the same contract and errors, arena placement included. The 4× arena-scratch trick is gone: import stages source weights in a typed NirBuffers::scratch f64 slice; arena and scratch each hold the weight-cell count exactly. Breaking buffer-API change, alpha.4-bound.
  • Per-neuron LIF populations + NirBuilder: a LIF node is the reference’s population — per-neuron param arrays quantize to per-neuron records in a lifs buffer (NirLifPopulation views); assembly enforces Linear rows == population size (reference type-check parity), one neuron per row with its own params. NirBuilder (std) assembles graphs in memory over the quantizer seam; export renders per-neuron arrays; the printable-ASCII gate is a JSON-container property only (new NonAsciiNodeName at export, never on the typed surface). Reference-emitted chain_population.json fixture pins the expansion end-to-end (imports → assembles → fires → re-imports state-identical).
  • Honesty note: findings R1-R5 were present in the published alpha.3 binary. No consumers are known (the module shipped within the day); all are fixed here, ahead of any consumer, targeted for alpha.4.
  • The HDF5 .nir container ships workspace-side, in neuralos-rt behind its hdf5 feature (vendored static HDF5, pre-read filter census, the reference’s own fixtures + nir_hdf5_gate) — the seam it feeds is the structured entry above.

§Status

0.1.0-alpha.9 is live on crates.io, the first release named gresil (alpha.8 and earlier: neuralos-snn): the pub walk (see “Since alpha.8”). Alpha.8 (2026-09-14T20:37:43Z from 6f03e1b, registry-verified, as neuralos-snn): FixedNetwork, a network in arrays, replays every plasticity-off trace bit for bit on the ESP32-C3 and under QEMU riscv64gc, with no panic path in its step, proven at link time; the traces; the spike ring out of the neuron; the MSRV tested (see “Since alpha.7”). Alpha.7 (2026-09-13T03:20:57Z from a974b9e, registry-verified): both divisions by 1000 narrowed to i32 when the value fits, dt_over_tau in u32, the spike ring’s masked stores, #[inline] on integrate_and_fire; the network’s step on the ESP32-C3 3,878 → 1,579 ns/step, behavior identical (see “Since alpha.6”). Alpha.6 (2026-09-11T15:54:50Z from d8a96b1, registry-verified): the [u32; N] spike ring, no runtime dependencies, rust-version declared, isi_stats_us in u128, and the ESP32-C3 step cost read honestly (see “Since alpha.5”). Alpha.5 (2026-08-22T13:59Z from 103fa59, registry-verified): the general four-kind graph assembly, EDGE_PULSE_QUANTA, the assembly gates, the R17 consolidation breaks and the STDP dt-overflow fix (see “Since alpha.4”). Alpha.4, the same day: NIR structured entry (pub quantizers, NirBuilder, per-neuron populations) + the R9 review fixes. The alpha.3 record: the adaptation-decay contract pinned by unit + live tests (equilibrates, never silences the net); synaptic_input_divisor — the coupling knob, new public API (default 10 = the historical weight/10 pulse; 0 rejected); network.rs split into csr.rs + stats.rs with every published path unchanged; the simd batch kernel doc’d mV-grid-only.

Tree == published. Test counts live in the CI log and the repo’s AGENTS.md § Commands, not here; the API may still move within alpha semver.

NIR itself: Pedersen et al., Nature Communications 15, 4962 (2024), DOI 10.1038/s41467-024-52259-9 — this crate’s nir module speaks the schema pinned to neuromorphs/NIR@7883c3c.

§License

AGPL-3.0-or-later. The notice is COPYRIGHT, the license text LICENSE; both ship in the package.

Re-exports§

pub use fixed::FixedNetwork;
pub use fixed::FixedSynapse;
pub use lif_neuron::LIFNeuron;
pub use lif_neuron::NeuronType;
pub use lif_neuron::VoltageResolution;
pub use network::NetworkTopology;std
pub use network::SpikingNeuralNetwork;std
pub use nir::NirImport;std
pub use nir::NirImportOptions;
pub use synapse::STDPRule;unstable-stdp
pub use synapse::Synapse;

Modules§

bridgeunstable-bridge
Unstable: behind unstable-bridge. Stage 2 of the ternary bridge: the format bridge (see docs/VISION.md and docs/TERNARY_FORMAT.md).
fixed
A network of fixed size: N neurons and S synapses in arrays, no heap, no plasticity, the std step’s order verbatim.
kernelunstable-bridge
Unstable: behind unstable-bridge. Stage 3 of the ternary bridge: the shared kernel (see docs/VISION.md).
lif_neuron
Leaky Integrate-and-Fire (LIF) neuron — clean port from v0.1.
networkstd
Spiking Neural Network — topology builders + step orchestrator.
nir
NIR — the Neuromorphic Intermediate Representation, slice 1: import (JSON container) + honest export for the node subset the substrate can honor exactly: Input, Linear, LIF, Output.
simdsimd
SIMD-accelerated batch LIF integration (AVX2, x86_64).
spike_recorder
Spike recorder: the bounded spike-timestamp history a caller keeps when it wants one.
synapse
Synapse model — clean port from v0.1 libneuralos/src/core/spiking_neural_network/synapse.rs.
trace
neuralos-trace v1, the trace format: a network’s run as text, a header line then one row per step, which a host and a board write alike and compare byte for byte.
trit
Ternary weight representation {-1, 0, +1} × per-tensor scale — Stage 1 of the ternary bridge (see docs/VISION.md).

Enums§

Error
Crate-level error type.

Type Aliases§

Result
Crate-wide Result alias.