Files That Live Inside Network Cables without hard drives.
ALS SubZero is an experimental project that stores files inside network cables while in flight. Instead of saving data to a disk or SSD, it keeps packets bouncing continuously between network reflectors, using the Bandwidth-Delay Product (BDP) of optical fiber as volatile memory. If circulation stops, the data disappears.
Engineering Architecture
How SubZeroEngine turns propagation delay into reliable volatile memory.
Microsecond Departure Pacer
Employs an exact token-bucket leaky scheduler calibrated against measured Round-Trip Times (RTT). Departure timestamps prevent network congestion, keep reflector queue sizes bounded, and sustain steady-state Bandwidth-Delay Product (BDP) circulation.
Cauchy Reed-Solomon
Payloads are partitioned into K data chunks and encoded into M parity chunks using Cauchy distribution generator matrices over GF(2^8). Any K of K+M received packets fully reconstruct the original block.
Castagnoli CRC32C Integrity
Every frame carries a fixed 24-byte binary header with magic bytes ALS1 and a 32-bit Castagnoli polynomial checksum. Maintains Hamming distance d=4 across full 4096-byte chunk payloads.
Active Parity Scrubber
Asynchronous worker processes incoming packet rings, inspects stripe completeness, reconstructs missing chunks via Gauss-Jordan matrix inversion, and re-injects repaired packets into the wire.
Interactive Responsive Diagrams
Native vector SVG renderings with zero iframes — high contrast, vivid labels, and responsive across desktop and mobile.
Capabilities & Practical Limitations
An honest, rigorous breakdown of what the system does and what it does not do.
What The System Does
Verified capabilities & core guarantees- Zero Local Disk Writes: File data lives entirely inside network cables while in flight. Verified 0.0 MB/s disk I/O; data never touches persistent SSD or magnetic media while circulating.
- Packet Loss Auto-Repair: Uses (4, 2) Cauchy Reed-Solomon over GF(2^8). Any 4 surviving chunks out of 6 reconstruct the full stripe, tolerating up to 33.3% chunk drop.
- Microsecond Departure Rate Pacing: Paces outgoing packet transmissions (default 100 μs minimum gap) using token-bucket scheduling so OS socket buffers never overflow.
- Castagnoli CRC32C Frame Integrity: Fixed 24-byte binary header with Castagnoli polynomial guarantees Hamming distance d=4 across full 4,096-byte chunk payloads.
- Interactive Tools & Management: Comes with a Unix-style interactive terminal shell REPL, local REST API endpoints, and a localhost web control console on port 8080.
- Zero External Dependencies: Core Python engine runs on Python 3.9+ using standard library modules only, plus an optional native Linux C FUSE daemon.
What The System Does Not Do
Practical constraints & physical trade-offs- Not a Replacement for Real Storage: This is an experimental proof-of-concept, not a substitute for SSDs, databases, or local RAM. The host still needs basic memory to run the client and socket stack.
- Strictly Volatile Persistence: If the network drops or you stop the client process, files vanish immediately from existence. There is no recovery after circulation stops.
- Network Propagation Latency: Reading files requires waiting for a network round trip (10 ms to 80 ms RTT), which is orders of magnitude slower than local NVMe or DDR RAM.
- 50% Parity Bandwidth Overhead: Adding 2 parity chunks to every 4 data chunks increases network wire traffic by 1.5× (6 / 4 = 1.5× wire load).
- Capacity Capped by BDP: Maximum in-flight storage capacity is strictly bounded by the physical network bandwidth and latency: C = Bandwidth × Round-Trip Time.
Handwritten Mathematical Calculations
8 mathematical problems solved by hand on paper before writing code. 21 high-resolution proof sheets.
ALS SubZero: Complete Handwritten Mathematical Calculations
Scanned notebook cover page detailing the 8 mathematical problems formulated and solved by hand before software implementation:
- Problem 1: Bandwidth-Delay Product Storage Capacity and 4120B Frame Bounds.
- Problem 2: Galois Field GF(2^8) Primitive Polynomial and Complete Log/Exp Tables.
- Problem 3: Constant-Time Multiplication via Logarithmic Table Sums.
- Problem 4: Multiplicative Inverses and Field Division for Matrix Solvers.
- Problem 5: Cauchy Generator Matrix Construction for Maximum Distance Separable (MDS) Codes.
- Problem 6: Cauchy Erasure Encoding (4 Data chunks → 2 Parity chunks).
- Problem 7: Full Erasure Recovery via Gauss-Jordan Inversion with Pivot Row Exchanges.
- Problem 8: Castagnoli CRC32C Frame Integrity Polynomial and Tamper Detection Proofs.
Cover Page • 8 Problems Overview
Problem 1: Bandwidth-Delay Product Storage Capacity
Calculates how much data can physically sit inside a network wire in flight using link capacity equation: C = Bandwidth × RTT.
- 100 Mbps / 20 ms RTT: 100,000,000 × 0.020 / 8 = 250,000 bytes ≈ 244 KB.
- 1 Gbps / 40 ms RTT: 1,000,000,000 × 0.040 / 8 = 5,000,000 bytes ≈ 5.0 MB.
- Frame Sizing: With a 4,096-byte payload and a 24-byte binary header (4,120 bytes total per frame), a 1 Gbps / 40 ms link holds:
N = floor(5,000,000 / 4,120) = 1,213 frames.
Page 1: Link budget & BDP derivations
Page 2: Frame count & 24B header correction
Problem 2: Building Galois Field GF(2^8) Tables by Hand
To perform error correction on single bytes without rounding or overflow, arithmetic is defined over GF(2^8) using primitive polynomial:
P(x) = x^8 + x^4 + x^3 + x^2 + 1 = 100011101_2 = 285 (0x11D)
Starting with generator α = 2, each step shifts left by 1 bit. If the value reaches 256 or higher (bit 8 set), XOR with 285:
- Power 8: 128 × 2 = 256 ≥ 256 ⇒ 256 ⊕ 285 = 29 (0x1D). So EXP[8] = 29, LOG[29] = 8.
- Power 12: 232 × 2 = 464 ≥ 256 ⇒ 464 ⊕ 285 = 205 (0xCD). So EXP[12] = 205, LOG[205] = 12.
assert GF_EXP[:13] == [1, 2, 4, 8, 16, 32, 64, 128, 29, 58, 116, 232, 205]
Page 1: Polynomial definition
Page 2: Generator powers
Page 3: XOR overflow steps
Page 4: Log/Exp synthesisProblem 3: Multiplying Two Arbitrary Bytes in GF(2^8)
Multiplying a ⊗ b without table lookups requires slow carry-less math. Using log/exp tables:
gf_mul(a, b) = EXP[(LOG[a] + LOG[b]) mod 255]
Example: Multiply 0x8E (142) by 0x2A (42):
- LOG[142] = 254, LOG[42] = 142
- Sum = 254 + 142 = 396
- 396 mod 255 = 141 ⇒ EXP[141] = 21 (0x15)
- Result: 0x8E × 0x2A = 0x15 (Fits precisely in 1 byte, zero integer overflow).
Page 1: Log-table multiplication
Page 2: Zero-case branch proofProblem 4: Multiplicative Inverses & Division in GF(2^8)
For erasure decoding, we must divide coefficients when inverting matrices:
a^-1 = EXP[255 - LOG[a]]
Inverses required for Cauchy generator matrix:
- inv(2): LOG[2] = 1 ⇒ 255 - 1 = 254 ⇒ EXP[254] = 142 (0x8E). Check: 142 ⊗ 2 = 1.
- inv(3): LOG[3] = 25 ⇒ 255 - 25 = 230 ⇒ EXP[230] = 244 (0xF4). Check: 244 ⊗ 3 = 1.
- inv(4): LOG[4] = 2 ⇒ 255 - 2 = 253 ⇒ EXP[253] = 71 (0x47). Check: 71 ⊗ 4 = 1.
- inv(5): LOG[5] = 50 ⇒ 255 - 50 = 205 ⇒ EXP[205] = 167 (0xA7). Check: 167 ⊗ 5 = 1.
Page 1: Multiplicative inverses and verificationProblem 5: Constructing Cauchy Generator Matrix (K=4, M=2)
Cauchy matrices guarantee every square submatrix is invertible over any finite field:
a_{i,j} = (X_i ⊕ Y_j)^-1
Disjoint index sets: X = [0, 1] (parity), Y = [2, 3, 4, 5] (data):
- Row 0 (x0 = 0): [1/(0⊕2), 1/(0⊕3), 1/(0⊕4), 1/(0⊕5)] = [142, 244, 71, 167]
- Row 1 (x1 = 1): [1/(1⊕2), 1/(1⊕3), 1/(1⊕4), 1/(1⊕5)] = [244, 142, 167, 71]
Generator matrix in hexadecimal:
A = [[0x8E, 0xF4, 0x47, 0xA7], [0xF4, 0x8E, 0xA7, 0x47]]
Page 1: Cauchy matrix construction & symmetryProblem 6: Cauchy Erasure Encoding (4 Data → 2 Parity)
Given 4 input data bytes: D = [42, 105, 77, 210] = [0x2A, 0x69, 0x4D, 0xD2]
- Calculating P0 (Row 0 of A):
(142 ⊗ 42) ⊕ (244 ⊗ 105) ⊕ (71 ⊗ 77) ⊕ (167 ⊗ 210)
= 21 ⊕ 39 ⊕ 84 ⊕ 58 = 92 (0x5C) - Calculating P1 (Row 1 of A):
(244 ⊗ 42) ⊕ (142 ⊗ 105) ⊕ (167 ⊗ 77) ⊕ (71 ⊗ 210)
= 237 ⊕ 186 ⊕ 226 ⊕ 186 = 15 (0x0F)
[42, 105, 77, 210, 92, 15].
Page 1: Input vector & matrix setup
Page 2: P0 vector multiplication
Page 3: P1 vector multiplicationProblem 7: Erasure Recovery via Gauss-Jordan Inversion
Network drop scenario: Routers drop D1 (105) and D3 (210). Surviving chunks: D0=42, D2=77, P0=92, P1=15.
- Surviving submatrix extracted from rows {0, 2, 4, 5} of generator matrix.
- Row swapping pivot algorithm places non-zero pivot 0xF4 on the diagonal.
- Gauss-Jordan inversion yields decoding matrix G_surv^-1.
- Reconstructing lost D1:
(123 ⊗ 42) ⊕ (224 ⊗ 77) ⊕ (5 ⊗ 92) ⊕ (4 ⊗ 15)
= 210 ⊕ 182 ⊕ 49 ⊕ 60 = 105 (0x69) [Bit-Exact Match] - Reconstructing lost D3:
(1 ⊗ 42) ⊕ (123 ⊗ 77) ⊕ (10 ⊗ 92) ⊕ (12 ⊗ 15)
= 42 ⊕ 222 ⊕ 98 ⊕ 68 = 210 (0xD2) [Bit-Exact Match]
Page 1: Drop scenario setup
Page 2: Submatrix selection
Page 3: Pivot elimination
Page 4: Submatrix inverse
Page 5: D1 & D3 byte recoveryProblem 8: Castagnoli CRC32C Frame Integrity Verification
Every frame carries a fixed 24-byte binary header with a Castagnoli CRC32C checksum:
G(x) = x^32 + x^28 + x^27 + ... + 1 = 0x1EDC6F41
- Why Castagnoli over IEEE 802.3: Standard CRC32 guarantees Hamming distance d=4 only up to 268 bytes. Castagnoli maintains d=4 across the full 4,096-byte chunk payload.
- Tamper Detection: Flipping any 1 bit causes immediate CRC mismatch. Corrupted frames are dropped and reconstructed via Cauchy parity.
- Undetected Error Probability: P = 2^-32 ≈ 2.33 × 10^-10 (1 in 4.3 billion).
- Verified in Unit Suite:
test_crc_tamper_detection ... ok
Page 1: 24B binary header & polynomial
Page 2: Single-bit flip tamper proofScientific Research Paper
Full academic preprint describing theoretical foundations, proofs, and empirical tests.
ALS SubZero: A Dynamic Delay-Line Network Memory Filesystem with Erasure-Coded Flight Persistence
@article{sami2026alssubzero,
title = {ALS SubZero: A Dynamic Delay-Line Network Memory Filesystem with Erasure-Coded Flight Persistence},
author = {Samin Sami},
journal = {Preprint},
year = {2026},
month = {November},
howpublished = {\url{https://github.com/Saminsami73/als-subzero}},
note = {ALS stands for Al Sami. Zero-disk in-flight storage engine.}
}
Empirical Verification & Benchmarks
Stress testing 16,384 bytes across 60 network circulation cycles under simulated packet drop rates.
| Circulation Loop | Data Size | Packet Drop Rate | Chunks Healed | SHA-256 Verification | Disk I/O Writes | Test Status |
|---|---|---|---|---|---|---|
| 0.0% Drop (Loop 1–15) | 16,384 Bytes | 0.0% loss | 0 chunks | 100% Bit-Exact | 0.0 MB/s | PASS |
| 2.0% Drop (Loop 16–30) | 16,384 Bytes | 2.0% loss | 20 chunks | 100% Bit-Exact | 0.0 MB/s | PASS |
| 5.0% Drop (Loop 31–45) | 16,384 Bytes | 5.0% loss | 78 chunks | 100% Bit-Exact | 0.0 MB/s | PASS |
| 10.0% Drop (Loop 46–60) | 16,384 Bytes | 10.0% loss | 151 chunks | 100% Bit-Exact | 0.0 MB/s | PASS |
Bandwidth-Delay Link Budget
Total in-flight storage capacity: C = Bandwidth × Round-Trip Time (BDP).
- 1,250,000 bytes volatile buffer
- ~303 active 4120B frames
- Campus LAN / Metro interconnect
- Zero hard drive / SSD usage
- 5,000,000 bytes in motion
- 1,213 active 4120B frames
- Cross-country IP path
- Active Cauchy parity scrubber
- 100,000,000 bytes in flight
- 24,271 active 4120B frames
- Inter-cloud fiber optic backbone
- Vanishes instantly when halted
Interactive Shell & Web Control Console
Dual management planes: Unix-style interactive shell REPL and local REST web dashboard.
Quickstart Verification Commands
Interactive Shell Command Reference
Project Origin & Architecture Heritage
From acoustic mercury delay lines in 1949 to modern packet propagation storage.
Delay-Line Computing Heritage
Early digital computers like Cambridge's EDSAC (1949) used acoustic mercury delay lines for primary memory. Electrical signals were converted into sound pulses traveling through tubes of liquid mercury, picked up by quartz transducers, amplified, and recirculated continuously.
Modern fiber-optic cables work under analogous physical principles. Light takes measurable time to propagate through silica glass (approximately 5 microseconds per kilometer), and packets take time to hop through network routers.
Earlier experiments like pingfs demonstrated that raw bytes could be bounced over ICMP echo, but failed catastrophically when even a single packet dropped or when fast networks overflowed operating system socket buffers. ALS SubZero solves both challenges: microsecond rate pacing maintains queue stability, while Cauchy Reed-Solomon erasure coding reconstructs dropped packets in flight without local disk writes.