Additional projects

Nexum

Communication behaviors such as routing, filtering, acknowledgements and retries often become dedicated runtime operations.

An experimental programmable communication fabric built around a deterministic execution primitive and explicit bounded state transitions, composed into graphs through caller-provided FIFO storage.

ExperimentalMPL-2.0C11
GitHub repositoryExample
Last verified
2026-09-16
Platform / runtime
Portable C11; caller-owned or fixed bounded graph, state, queue and output storage

Purpose

Communication behaviors such as routing, filtering, acknowledgements and retries often become dedicated runtime operations.

Execution model

1Builder and compiler helpers→2Program IR→3deterministic lowering→4FIFO graph runtime→5bounded state transition

Primitive and graph model

A primitive evaluates P_config(state, event) → (next_state, bounded_outputs). Configuration selects inputs, an ALU operation, predicate, optional state/event-field updates and bounded output masks. Program IR separates logical cells, state domains, edges, inputs and outputs from runtime array addresses.

Build and execute

The builder assigns deterministic identifiers and routing order; compiler helpers express foundational compositions. Lowering creates a graph over caller-provided arrays and graph execution uses FIFO order. Time and randomness are explicit events. Primitive and graph execution do not allocate; program, queues, domains, graph arrays and outputs use caller-owned or fixed bounded storage.

Determinism and validation

D1 is primitive determinism and D2 is ordered replay determinism. D3 schedule-independent determinism is a conservative graph-analysis result, not guaranteed for every graph. CTest coverage, fuzzing and sanitizer workflows are documented. Nexum is experimental research software, not production-ready or formally verified.

Typical use

Model a bounded state transition as P_config(state, event) → (next_state, bounded_outputs)
Compose graph primitives and execute them in FIFO order
Use Program IR, the builder and compiler helpers to declare and lower programs
Represent time and randomness as explicit input events
Replay ordered event traces under the documented D1/D2 guarantees

Quick start

#include "nexum_compile.h"

nexum_compile_spec_t spec = {0};
nexum_compile_requirements_t requirements;
nexum_program_t program;
spec.behavior = (uint8_t)NEXUM_BEHAVIOR_PASS;
if (nexum_compile_requirements(&spec, &requirements) != PNP_OK) return 1;
if (nexum_compile(&spec, requirements.capacities, &program) != PNP_OK) return 1;

Repository evidence

  • README specifies P_config(state, event) → (next_state, bounded_outputs), fixed-width explicit state domains and deterministic IDs/routing order
  • Primitive and graph execution do not allocate; queues, graph arrays, domains and output buffers are caller-owned or fixed bounded storage
  • README defines D1 primitive and D2 ordered replay determinism; D3 is conditional graph analysis
  • CTest covers semantics, FIFO order, replay, generated cases, serialization, retry, IR, builder and compiler helpers; separate workflows cover fuzzing and Clang ASan/UBSan

Limits and status

  • Experimental research software; not production-ready, a complete network stack or a transport protocol
  • D3 schedule-independent determinism is not guaranteed for every graph; it is a conservative graph-analysis result
  • Queue capacity, output capacity and execution budgets are explicit
  • Tests and sanitizer runs do not constitute formal verification or a security proof

All projects · Additional projects