Schema–Segment Composition Computing System

SSCCS (Schema–Segment Composition Computing System) is an open‑source computing systems initiative that replaces the sequential instruction‑centric model with a geometric observation‑driven model: spatial computation is the collapse of structured potential across a coordinate space composed of immutable Segments, Scheme and dynamic Fields composition. Parallelism and verifiability emerge from the structure itself, with near‑linear scalability and energy efficiency as consequences; state is the result of projection, and time is one coordinate among many.

SSCCS is built by the SSCCS Foundation under an open‑core model, guided by its operational direction and philosophy. The stack spans the full pipeline, from formal specifications, through a software compiler toolchain, to an open hardware architecture. The model is actively materializing on the engineering frontier of the current silicon paradigm through domain instantiations built on our three core infrastructure pillars: synTagma, neXus, and kineTics.

Stack

SSCCS is a software-first project: a compiler toolchain, a runtime, and an open binary format. The compiler maps structural descriptions through a layered lowering chain to hardware-specific backends. A target-agnostic HAL keeps the ontological core independent of the execution substrate. The same Scheme projects onto a CPU, an FPGA, or a processor-in-memory architecture without rewrites. A Rust reference implementation validates all core primitives.

Why

• Data movement dominates energy costs in modern computing. SSCCS keeps the structure stationary while projections emerge.
• Parallelism is inherent to the structure. Independent sub‑graphs within a Scheme can be observed concurrently—no locks, no synchronisation.
• Structural descriptions are compiled directly into the hardware substrate at build time. There is no runtime interpretation; the structural document is embedded into execution itself.
• Security and auditability are geometric consequences, not add‑on features. Immutable Segments carry cryptographic identity by design, and the geometric manifold provides inherent isolation. Independent sub‑graphs cannot interfere, and every observation is a deterministic, traceable collapse from blueprint to result.
• Digital sovereignty is a design property, not an afterthought. Policy sandboxes are enforced at the binary level, so organizations and individuals keep control of their computational environments, free from proprietary lock-in.

Where

Workloads where data movement is the binding constraint:

• Space systems: radiation tolerance from structural reproducibility. After an upset, the system re-observes the same immutable Scheme and deterministically returns to the same configuration, without redundant hardware.
• Embedded and edge systems: a no-allocator coordinate space fits OS-less microcontrollers and radiation-tolerant hardware, replacing hash units with combinational decoders.
• AI inference: model weights stay in place and computation moves to them, attacking the memory-bandwidth bottleneck behind inference latency and energy cost.
• Swarm robotics: agents observe a shared blueprint locally, making collective behavior emergent without coordination chatter.
• Climate and scientific computing: dependency grids become adjacency relations compiled into memory, so each timestep is a parallel observation instead of data movement.
• Scientific data infrastructure: coordinate indexing replaces hash lookup in large datasets, collapsing read-request bottlenecks from hours to seconds.

Now

• The core compiler and runtime are under active development. Current focus is on Field composition algebra: making constraint sets composable while preserving observation determinism, with parallel work on compiler pipeline hardening and hardware mapping.
• Nexus: a domain instantiation of the SSCCS model. It provides contract‑governed, agentic coordination that ingests and connects heterogeneous knowledge into a unified, queryable structure.
• Strategic partnerships: with infrastructure leaders to extend the reach of agentic research environments.
• Hardware validation: phased prototyping from software emulation to FPGA deployment, with a parallel track for radiation‑tolerant platforms.

Projects

The stack materializes as independent domain instantiations on the same substrate. Each one solves its own problem and strengthens the primitives for all.

• PoCs: SSCCS is a paradigm, not a single implementation. Its abstract primitives are being proven in parallel across RTL, RISC-V assembly, and current-language PoCs before a reference compiler and runtime take shape.
• neXus: homeomorphic runtime fabric unifying swarm agents and spatial storage.
• synTagma: spatial coordinate space computing from software to hardware; identity without hashing, the coordinate is the address.
• Chton: materialization IO fabric for coordinate spaces over physical media; the storage format is the memory layout.
• ExaVerif: exhaustive verification for RISC-V custom instructions, replacing random testing.
• Actus: spatial execution runtime for agents and system actions at scale.
• Telos: general agent runs as a fleet of peers with coordinate teleport.
• kineTics: supervises every executor type under one coordinate-based contract.
• SDBS: single-path artifact compiler for reproducible, auditable knowledge base.

Engagements

We welcome partnerships from academia, industry, and public institutions worldwide — any nation with aligned public-interest programs. Domain instantiations of the SSCCS model are already in motion; we are selective about collaborators who bring engineering depth and long-term commitment. Opportunities include research collaboration, software toolchain development, and joint hardware validation. Current representative engagements:

• AI infrastructure ecosystem: LLM serving engines
  • vLLM: contributing to the industry‑standard LLM inference engine through our structural computing stack.
  • llama.cpp: eplacing KV cache indirection with coordinate arithmetic — O(1) access without indexing in CPU‑first inference.
• CERN science software ecosystem: supporting the pursuit of extreme computational challenges in High-Energy Physics (HEP) through our software stack.
• Databases: Multi-dimensional query bottleneck
  DuckDB: replacing full-table scans for multi-dimensional point and range queries with coordinate-lattice subspace addressing.
• Eclipse Foundation CORE-V ecosystem: advancing open‑source RISC‑V verification and validation through our exhaustive verification primitives.

For the full list of current engagements, see Current Engagements.

Sponsorship

SSCCS is an independent, open-source computing infrastructure committed to public-good infrastructure. The official sponsorship charter on GitHub Sponsors describes the funded work: open-source releases, free documentation, and research into energy-efficient, verifiable computing.