Skip to content

About

SpiralCore networking, exact geometric transport, and research

Resources

Contributing

Stars

3 stars

Watchers

0 watching

Forks

Repository files navigation

SpiralCore

Move fewer bytes. Reconstruct every byte. Measure the compute cost.

SpiralCore is an experimental Rust networking and lossless object-transfer project. Cooperating endpoints reuse verified state, compare exact encodings, and send the information needed to reconstruct the original bytes. The implementation combines warm-object reuse, sparse deltas, schema codecs and bounded ternary/Kuramoto/CA replay with conventional zstd/raw controls.

Cooperating endpoints prepare, transfer, reconstruct and verify an exact object.

The four images are conceptual software illustrations, not custom hardware or experimental evidence. Figure provenance →

Start here · Architecture · Measured results · Current status · Evidence · Contributing

Current delivery status

Working components and measured native demonstrations are published. The complete installed MVM networking contribution is still in development. The GitHub roadmap, #42, is the delivery authority; a component merge or green platform test is an intermediate checkpoint, not completion of that program.

The latest reviewed source checkpoint, PR #315 qualifies original store custody when final directory removal succeeds but parent sync refuses. Contributor MVM f2ddbcbf passes full source gates, SDK/paired scopes and 62 native custody controls. The current report retains original failures, verified executable reuse, actual byte/CPU/lifecycle measurements and remaining allocator/concurrency, signed-runtime, platform/WAN and capacity work. The former 107 GiB SSD scratch remains privately archived on HDD; builds use HDD and torrent/media paths are untouched. Historical executable loss remains explicit. These component results qualify no new booted-MVM or WAN delivery.

Linux/Firecracker and Apple Silicon/HVF both passed clean delivery and automatic retry on the same mailbox code. In four single-host runs, guest A staged a 313-byte SpiralCore frame. Guest B recovered all 257 payload bytes, including the trailing zero, synced and reopened its local copy, and acknowledged its lease. Both original helpers stopped unassisted in each run. The loss trials withheld B’s first signed receipt. A’s agent retried the original envelope, B returned the identical receipt, and an authenticated read after the ACK found the queue empty.

One installed Firecracker pair completed 2,049 distinct durable transfers in a single session. B independently read back all 526,593 payload bytes, and A verified each signed B receipt and advanced its contiguous settlement prefix. The relay carried 12,052,072 bytes toward B and 2,487,009 bytes back. Median stage-to-settlement time was 1.764 s and p95 was 1.878 s. The series took 3,588.550 s with one transfer outstanding, interleaved with a sequential authorized empty Receive per transfer. Both original helpers exited unassisted. The first larger trial stopped at 1,480 completed transfers. Multi-tenant concurrency and cross-host durable delivery remain open. Sustained measurements and earlier failure · Earlier 65-transfer result

Two installed Linux guests now exchange warm objects through their own mailboxes. Guest A sent a 4 KiB object cold, then offered it again to the same worker on B. B returned all 4,096 bytes exactly on each transfer. The cold transfer required four signed Calls. The repeat needed one Call, one Reply and zero literal payload bytes.

Fully metered Firecracker pair on one Linux host Cold Exact repeat
Object-v1 requests and replies 4,658 B 190 B
Both guest↔host vsock links at port 5257, reads plus writes 481,989 B 124,813 B
Sealed helper↔helper socket traffic, including signed receipts 63,610 B 14,170 B
CPU in A / B’s guest workloads 5.144 / 23.898 ms 1.819 / 7.404 ms
Elapsed through both guest results and exact readback 3.793 s 1.045 s

On this pair the repeat used 74.1% fewer bytes across the two guest-vsock links and 77.7% fewer bytes on the sealed host sockets. These are separate observation points on the same delivery. All six original streams produced complete records. Both helpers stopped without assistance, and both VMMs exited. The earlier pilot retained its guest-port overflow at 64 exchanges. Two fresh installations then compared fixed codecs on the same 4,096-byte fixture. Raw used 4,658 Object-v1 bytes and 63,801 sealed bytes cold. Whole-object zstd used 4,674 and 64,055 respectively. Each same-worker repeat used 190 Object-v1 bytes. Native HVF qualification for this object profile and a two-host WAN trial remain open. Matched raw and zstd controls Reproduction, complete counters and earlier pilot

The four single-message trials are shown below.

Backend and case Sealed A → B Signed receipt read from B Verified receipt returned to A’s helper ACK and host comparison of B’s readback
Linux x86-64 Firecracker, clean 5,808 B 1,188 B 105.627 ms 0.440133 s
Linux x86-64 Firecracker, first receipt withheld 5,836 B twice 1,193 B twice 161.334 ms on retry 1.361047 s
Apple Silicon HVF, clean 5,863 B 1,208 B 85.394 ms 2.117140 s
Apple Silicon HVF, first receipt withheld 5,854 B twice 1,214 B twice 100.209 ms on retry 0.550778 s

Times start at A’s first SDK Call. In the loss trials A received zero signed receipt bytes on the first turn, then the complete receipt on retry. Those trials included the extra empty read. Each platform report records endpoint CPU and full port-5257 stream counters. These same-host measurements qualify the mailbox workflow. WAN speed and savings against a matched zstd transfer remain unmeasured for this workflow. Linux measurements · Apple measurements · Initial Linux assisted-shutdown trial.

Earlier witnesses isolate stages of this path. The host exercised two independently addressed own mailboxes, one guest recovered and acknowledged its own durable object, and two host adapters retried a sealed envelope across a journal restart. The earlier addressed guest Calls timed out before readback. Two own mailboxes · Single-guest readback · Restart and retry · Earlier deadline result.

The installed-startup report records actual Linux worker/signing-helper checks: a fresh installation starts and collects its original signer; a previously used installation with a missing journal refuses before readiness; a directly invoked worker with no configured home refuses without modifying its owned fixture. The publication/custody/replay candidate passes 21 selected cases. A Linux daemon recovery test now shows a signed deregistration waiting for its original handler and preserving the other VM’s record; conflicting inventory refuses without a rewrite. Eight follow-up checks pass after binding resumed callers to their original resource charges. In a Linux worker recovery test, the client received the deregistration reply and the worker collected its original signer before exiting. Retirement with a per-VM mailbox helper remains open.

Path Published implementation and evidence Remaining acceptance
Cooperating objects Authenticated QUIC object service; shared runtime/cache/schema core; exact durable readback Current-source two-host Internet WAN qualification
Ordinary TCP/UDP Linux TUN paired tunnel over authenticated QUIC; real IPv4/IPv6 flows and calibrated shaped-link trials Other packet-attachment platforms and deployment/WAN acceptance
MVM mailbox Canonical encrypted envelopes, native HVF/Firecracker transfers, and installed Firecracker qualification for sustained Calls and receipt recovery Complete installed-service release, concurrent capacity, canonical WAN, and security qualification
MVM FlowMux Cross-platform paired stream components and one installed Linux Firecracker guest with verified policy decisions and exact application readback Full installed package release, sustained operation, concurrent capacity and cross-host WAN
Installation/storage foundations Installed-owner/supervisor components, managed reservations and native Windows private-storage components End-to-end aggregate ownership, recovery and supported capacity envelope
Owner access Development/sealed-mode integration is active, unmerged work Canonical authority/lifecycle, shared-core payload binding and native acceptance

The public installed FlowMux runner completed a fresh Linux Firecracker invocation with one refused destination and a 5,804-byte exact echo in each direction. The final source's guest echo took 199.140 ms wall and 4.863 ms process CPU; the peer counted 3,661 incoming and 3,234 outgoing TLS bytes. Preparation through original-owner retirement took 15.090 s. The normal locked Cargo build uses public MVM host source 7b224540 with the separately pinned official rc.2 guest runtime. Both Linux feature configurations passed strict Clippy, and all 160 canonical controller library tests passed under default parallel execution. The signed audit verifies the original session's allow/deny decisions, but its plan/image fields remain unbound. Cross-host WAN, matched codec baselines and full package acceptance remain open. Final measurements and reproduction · First public run and timing variation · Earlier trial 9

The earlier FlowMux component baseline was PR72, merged as 25a1c786; PR77 publishes its reviewed release packet. The following release added readiness and stream closure. All seven native process roles passed 47 component checks. PR104 results

The native Windows FlowMux test reconstructed 4,096 blocks of 16 KiB in each direction, 64 MiB per peer. Both peers ran in one process over local TCP/TLS. The ordinary runs completed in 187.972 s on Server 2022 x64, 153.280 s on Server 2025 x64 and 144.730 s on Windows 11 ARM64. All five final runs passed. Two earlier runs reached an operation deadline, including one while the receiver processed Finish. Repeatable tail latency and cross-host WAN acceptance remain open. Per-run CPU, TLS byte counts and earlier failures · FlowMux integration tracker

Unmerged work includes the canonical resident parent, exact-process guardian custody, disposable endpoint-disk inventory, admitted FlowMux/access activation, and the ordered Small profile candidate. These are not part of PR72's accepted source. Current checkpoints, failures and open gates → Published development code: SpiralCore integration 8476d758 and MVM fork 081901d02. The resident lifecycle report records one original backend, two cancellation-safe resident slots, real registry resource drain and protected lifecycle tests. A caught operation panic fences the whole owner. The public dependency graph and remaining endpoint/native gates are recorded explicitly. The newer helper fixes are now published directly in the MVM fork; the earlier source bundle remains a historical recovery record. The latest endpoint-owner checkpoint connects actual guest, endpoint and disposable-store reservations to the canonical partition and resident cleanup path. Eleven focused Linux entries and strict Clippy pass; two reproduced ownership/cleanup defects and their fixes are retained. The resource profile remains inactive pending the complete helper model and positive native endpoint-retirement witness. These tests boot no guest and add no new transfer-performance claim. These checkpoints are available for review; native installed integration, capacity and WAN performance still require acceptance on the final combined source.

The resident/helper successor connects the actual canonical daemon/signer to the resident's original backend. It verifies shutdown and keeps resource credits charged until the final registrar reference drops: 22 ordinary passing checks plus one separately executed actual helper case. Its original config/admission binding and dependency identities are recorded with the source. These tests boot no guest.

The mandatory telemetry capacity check now rejects an endpoint allowance smaller than the canonical 8 MiB records cap before resource or directory effects. The successor passes 23 ordinary parent checks and strict Clippy; real-helper cases are ignored in that ordinary run. The retained-catalog successor implements original retained-file ownership, the disposable/retained split and durable denial after catalog loss. Its final release library run passes 152 entries with two helper cases ignored; scoped Clippy passes with three unconnected-constructor warnings. All 134 compiled inputs match its Git source. Original failures and independent reviews are retained. Restart adoption, incomplete-I/O recovery and the installed producer/native consumer remain open. The installed profile is inactive; these checkpoints add no transfer-performance, accepted capacity or FIPS claim.

The latest reader/TLS development checkpoint preserves original reader ownership and promptly rejects EOF during TLS authentication. Its 43 focused Linux checks and ten terminal-close repetitions pass; all 385 executed source inputs match the published checkpoint. Installed service activation remains separate. The scanner allocation report records all 325 canonical rule selections with exact legacy output comparisons; it informs the shared service budget without claiming an application RSS bound.

Architecture and protocol boundaries

OSI reference and the actual application, transport, TUN and guest-host boundaries.

SpiralCore's object identity, selection, reconstruction and publication state are application-protocol functions. Their resemblance to OSI session or presentation functions does not make them separate standardized Layer 5/6 wire protocols. Carriers retain their own authentication, framing and lifecycle.

Boundary Actual placement
Application / object core Authorization context, object identity, codecs, reconstruction, verified publication
TCP/TLS component TLS-protected TCP stream; bounded object mapping above the carrier
QUIC services Reliable object streams or packet datagrams over UDP/IP; QUIC integrates TLS key establishment and packet protection
Linux TUN Layer 3 attachment: inner IPv4/IPv6 packets enter a paired tunnel
Physical network Ordinary outer UDP/IP and existing Ethernet/Wi-Fi/NIC stack
MVM guest–host Canonical application envelopes over virtio-vsock; vsock is a transport, not OSI Layer 5 or owner authorization

One shared Rust object core, explicitly versioned endpoint mappings. The object-v1 contract defines the common object frames and codec identities. The object gateway and MVM adapter reuse that core; they do not copy a codec or replace the canonical MVM envelope. Independent packet encoding is a separate documented mapping, not cross-packet object reuse.

Mailbox delivery, FlowMux network forwarding and owner access have separate admission, queues, rates, audit and lifecycle. A mailbox grant does not authorize network egress or a shell. A TCP destination grant does not authorize a different UDP/QUIC exit. Profiles, hashes, vsock connectivity and successful handshakes do not manufacture permission. Canonical MVM delivery requirements →

Cooperating object applications

The sender prepares an eligible exact representation at an authorized plaintext endpoint, before carrier encryption. The receiver authenticates the carrier, checks scope, reconstructs and verifies, then commits to its private store.

sequenceDiagram
    participant A as Authorized sender
    participant C as Shared object core
    participant B as Authorized receiver
    A->>C: Object + admitted state/profile
    C->>C: Choose recipe/residual, cache, schema, zstd or raw
    C->>B: Versioned object frames through authenticated carrier
    B->>B: Reconstruct, check length/digest, durable publish
    B-->>C: Authenticated publication acknowledgment
    C-->>A: Verified publication result
Loading

Publication is distinct from exactly-once application processing. Candidate selection can choose conventional bytes when reuse is ineffective; missing required authority or peers cause refusal, not an insecure transport fallback. Object service, configuration and ALPN →

For socket programmers — published FlowMux component contract:

API / boundary Contract
TlsCarrier + enrolled ScopeAuthority Match actual mutual TLS identity/role and enrolled scope before ObjectChannel::from_authenticated; a connected socket alone grants no permission
ObjectChannel Send/serve shared-core objects; application MAX_BLOCK is 16 KiB, not a whole-stream or whole-memory limit
Duplex::split Separate DuplexWriter, DuplexReader and owned JoinGuard; retain/join lifecycle custody
MappedStream Standard Read/Write facade over Duplex; partial I/O is normal, with a configured bound per I/O call rather than an automatic whole-stream deadline
Cancellation / half-close Fatal cancel fences later buffered delivery; normal half-close preserves valid reverse drain
Acknowledgment Verified object publication is not proof of application processing

These APIs do not construct canonical MVM route/access grants.

Ordinary sockets through a paired packet tunnel

Applications use ordinary sockets; Linux TUN gateways carry their packets through QUIC over normal NICs.

Applications keep their TCP/UDP sockets. Operator-configured routes deliver packets to Linux TUN; paired gateways encode independent packets and restore them at the peer. This path uses raw/zstd selection, not CA or a cross-packet warm base. Already-encrypted HTTPS/QUIC payloads normally have little useful redundancy.

sequenceDiagram
    participant A as Application / kernel
    participant G as Local TUN gateway
    participant H as Peer TUN gateway
    participant B as Peer kernel / application
    A->>G: Routed inner IP packet
    G->>H: Authenticated QUIC datagram(s) over outer UDP/IP
    H->>B: Reassembled exact inner IP packet
    B->>H: Inner IP reply
    H-->>G: Protected QUIC datagram(s)
    G-->>A: Exact restored reply packet
Loading

This is a paired Layer 3 tunnel, not a Layer 2 bridge, arbitrary Internet egress, or a NIC/driver modification. Address allowlists and bounded fragmentation/ reassembly remain enforced. Linux setup and packet protocol →

MVM mailbox and keyless relay

Two MVM guests encode and reconstruct inside their plaintext boundaries while a host relays sealed canonical mailbox envelopes.

The illustration shows the mailbox lane in a conceptual two-host arrangement; it is not a qualified WAN run or a claim that every vsock service is encrypted.

In the two-guest witness, the sender invokes the shared object core before canonical mailbox encryption. The host relay forwards sealed envelopes without message keys; it performs no plaintext compression. Reconstruction happens after receiver authentication/decryption. A one-guest/authorized-host-endpoint variant also exists. Keyless forwarding is not a host-blind confidential-computing claim.

sequenceDiagram
    participant A as Sender guest
    participant H as Keyless host relay
    participant B as Receiver guest
    Note over A,B: An object may require multiple Calls
    A->>A: Authorize + encode plaintext with shared core
    A->>H: Canonical encrypted Call
    H->>B: Same sealed envelope
    B->>B: Apply frame and publish only after object verification
    B-->>H: Separate canonical receipt and application Reply
    H-->>A: Sealed receipt + Reply
    A->>H: Canonical Reply receipt
    H->>B: Same sealed receipt
Loading

Call admission, object publication, application Reply and Reply acknowledgment are separate facts. The normal guest path remains strict; explicit reconciliation reuses the original Call identity and deadline rather than silently retrying. MVM assigns vsock port 5257 to the mailbox. FlowMux uses its own service on 5253. For the trusted-host local-durable path, the destination helper commits the sealed envelope to its journal before signing a V2 receipt. The reader’s later ACK identifies the delivery lease. A forwarding relay can carry the envelope and receipt without holding the journal’s signing key. Upstream port allocation · Journal and endpoint bindings. Native witness · Reconciliation

Mechanisms and exactness

Decode(verified receiver state, versioned recipe, exact residual) = original bytes
Mechanism Concrete role
Ternary DAG store Immutable structural sharing; distinct from runtime prediction
Ternary/Kuramoto/CA runtime Replay bounded versioned transitions from a canonical checkpoint
Acknowledged warm state Reuse an object the scoped receiver has verified
Sparse COPY/LITERAL residuals Preserve exact edits, including length changes
Schema fitting Share a template; encode values and unmatched literals exactly
Prepared state Amortize prediction/codec setup; charge that setup in results
Byte-first selection Compare eligible runtime, sparse, schema, zstd and raw representations

A short recipe is useful only when its prerequisites are present. Independent information must already exist in authorized receiver state or cross the link. Length/digest checks precede publication acknowledgment; experiments additionally compare independently reopened bytes. Hash identity does not authorize access.

For Combined, exhaustive evaluation is the published default; CPU-conscious selection is opt-in and can miss a smaller candidate outside the measured workload. Recipes select bounded built-in operations, not received executable code. Logical replay steps do not establish physical clock synchronization or exact cross-machine timing; CPU measurements do not establish energy savings.

Selected matched results

These are source-pinned experiments, not performance promises for every current build. Accounting domains and workloads differ: captured IP, canonical stream and HTTP-body bytes are not interchangeable. CPU is already part of elapsed time; subtracting it does not isolate send time. All tables retain their setup, verification, failures and source details in the linked report.

Object gateway — three paired trials, calibrated 80 ms RTT / 10 Mbit/s. Source 30792f17d0a596c4344e4780ebd4b8f455e3bedb; persistent sessions contain eight targets at each of 1,047,202 and 14,851,384 bytes, including paid setup.

Encoding Captured IP bytes, both directions Both endpoint process CPU Client completion
Exhaustive Combined 33,946,691 1.955 s 31.038 s
CPU-conscious Combined 33,943,850 1.924 s 31.061 s
Prepared whole-object zstd 58,149,609 2.471 s 49.862 s

All 288 deliveries reopened exactly. CPU-conscious had 0.045% worse paired-median full-session elapsed than exhaustive; on the unshaped local link its elapsed was 1.41% worse than whole-zstd. Full workload, paired ratios and losses →

Displayed cells are column medians. Paired percentage changes use per-trial ratios and need not equal ratios of the displayed medians.

Packet tunnel — three primary IPv4 trials, calibrated 80 ms / 10 Mbit/s. Source 9dd283ca366d6075bd6b423c3a42aa928e222ce2; three 16 MiB TCP objects on one persistent connection plus UDP smoke. These are shaped local Linux trials.

Encoding Captured IP bytes, mixed session Both gateway process CPU Three-object client time
Raw 62,681,599 4.947 s 46.953 s
Conventional zstd 28,472,420 3.294 s 20.540 s
Fast zstd 28,034,434 3.137 s 20.653 s

The complete campaign passed 32 sessions/256 exact endpoint receipts and retained 3,027 finite-queue congestion drops. Fast zstd was slower on the fast local link: 0.904 s versus Raw's 0.773 s. Calibration, capture and adaptive losses →

Installed MVM witness — single local fixed-order pairs, two actual guests. Eight 14,851,384-byte targets; Combined pays checkpoint/schema setup. Exact source and protected-binary identities are in the native report.

Native backend / encoding Both-direction canonical bytes Sender guest CPU Receiver guest CPU Lifecycle wall
Linux/Firecracker whole-zstd 107,301,660 4.488958 s 3.707541 s 8.814947 s
Linux/Firecracker Combined 62,491,548 2.963787 s 2.519790 s 6.392388 s
macOS/HVF whole-zstd 107,276,257 15.335437 s 11.293480 s 30.038789 s
macOS/HVF Combined 62,546,739 9.181874 s 5.281349 s 16.368091 s

All objects reopened exactly through independent verifier boots. Two vsock hops carry twice the canonical count; neither is a NIC capture. Host/VMM CPU overlaps nested guest activity and is reported separately. The earlier smaller Linux pair retains a 0.685% lifecycle loss. These are not matched OS comparisons or WAN runs.

Earlier Internet WAN experiments remain useful historical evidence, with HTTP-body accounting and different sources/transports. They do not qualify the current QUIC or canonical MVM path.

Platform and role matrix

Role Recorded scope Boundary
Linux x86_64 / Firecracker Native guest transfers and installed death/recovery witness Full resident/shared-budget/WAN acceptance open
Apple Silicon macOS / HVF Native guest transfers, installed durable mailbox and lost-receipt recovery HVF death recovery and integrated capacity/WAN open
Linux x86_64 + ARM64 Native portable client/stream components ARM64 component execution is not Firecracker host evidence
macOS ARM64 + Intel Native portable client/stream components Intel component execution is not native MVM hosting
Windows Server 2022/2025 x64 + Windows 11 ARM64 Native client/TLS components and private-storage components No native Windows MVM host or end-to-end durable gateway/WAN claim
Linux TUN adapter Native IPv4/IPv6 packet attachment Other attachment platforms are not established here

Each FlowMux platform row ran both endpoints in one native test process on one host. Cross-OS pairs and booted guests require separate tests. Windows storage uses the same protocol with an isolated Win32 backend and supported NTFS profile. Portable compilation, WSL and client success do not substitute for native backend execution. Platform contract · Current acceptance gates

Security and deployment scope

The MVM submission targets unclassified/CUI deployments with a concrete FIPS 140-3 cryptographic deployment profile, tracked in #83. Current builds have no established FIPS-validated deployment profile. Qualification must map every security-relevant operation to the exact validated module, version, build, operating environment and approved mode. Transport crypto and canonical mailbox/access crypto both require that mapping; changing outer TLS alone does not qualify inner operations. NIST CMVP records module validations, which are distinct from whole-system security and customer authorization.

This remains one codec/protocol with explicit deployment and endpoint profiles. Compression runs at authorized plaintext endpoints before the canonical encryption boundary. Encrypted relays retain their forwarding role. Tenant/cache isolation, secret-bearing compression, replay, revocation, key lifecycle and retained audit data need their own security evidence. Synthetic demonstrations and lossless readbacks do not establish CUI, FIPS or classified-network approval.

Build and run

Use Rust 1.97.1 for the recorded builds. Packages are standalone Cargo crates with their own committed lockfiles; no root Cargo workspace is required. The example uses a POSIX shell. Windows private storage requires a drive-absolute NTFS root under its native profile.

git clone https://github.com/R4-Laboratories/SpiralCore.git
cd SpiralCore
rustup toolchain install 1.97.1 --profile minimal

# Loopback-only synthetic object demo; choose a fresh cache directory.
cargo +1.97.1 run --release --locked \
  --manifest-path crates/spiralcore-transfer/Cargo.toml \
  --bin spiralcore -- demo --cache local/first-demo/cache

# Authenticated QUIC object service and Linux packet-gateway binaries.
cargo +1.97.1 build --release --locked \
  --manifest-path crates/spiralcore-gateway/Cargo.toml --bins

The demo is unauthenticated loopback tooling, not a WAN service. Authenticated services need the documented peer pins, certificates, scopes and configuration. TUN requires its documented Linux privileges/routes. Native MVM needs the pinned MVM source, kernel, guest image and backend-specific setup; default Linux live builds select the guest, while linux-host selects the host role.

Task Entry point
Object API, demo and verified storage Transfer crate
Paired packet gateways Gateway setup
Runtime/cache/schema object service Object gateway
Native MVM build and role selection MVM witness, Linux host
Canonical mailbox and FlowMux mapping Mailbox adapter, FlowMux contract

Evidence, research and contribution

The UORC v0.3.0 comparison examines its released context model, frame deduplication and decoder techniques against SpiralCore's warm-cache, schema and CA paths. It records published byte/compute tradeoffs, resource and integration limits, and proposed matched experiments. This is source research; no production codec has been replaced.

Public artifacts link source pins, checksums, compact raw observations, analysis, failures and reviews. The GitHub evidence release provides reviewed larger captures/receipts without a private-dataset account. Archived executables omitted from that release retain source/hash provenance; publication does not silently relicense third-party binaries. Newer component packets are linked from current status.

The wider geometry/E8/routing work is described in the FBS mechanism guide and research webpage. Those ideas are not automatically enabled routing mechanisms in the packet gateway. Rust is the active product and measurement language; historical prototypes remain preserved.

Original SpiralCore code and new documentation are MIT-licensed. Imported code, research and historical artifacts retain their own terms. See LICENSE, LICENSING, PROVENANCE and CONTRIBUTING.

About

SpiralCore networking, exact geometric transport, and research

Resources

Contributing

Stars

3 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages