In-Flight Delay-Line Loop: Active (0.0 MB/s Disk I/O) • ALS1 Protocol / GitHub Repo →
In-Flight Delay-Line Memory // Zero Disk I/O

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.

Designed and built by Samin Sami • ALS stands for "Al Sami"
engine_demo.py
0 MB/s Disk_Write_IO
100% Recovery_Rate
30 ms Packet_RTT
0.0 B FUSE_Writes

Engineering Architecture

How SubZeroEngine turns propagation delay into reliable volatile memory.

Pure Python + Native C (Linux FUSE)
SubZeroEngine Core

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.

Target RTT: 10.0 ms – 150.0 ms
Pacer Jitter: < 120 μs
Circulation Loop: Continuous UDP / ICMP
Galois Field Arithmetic

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.

Default Matrix: K=4, M=2 (50% Parity)
Packet Loss Tolerance: Up to 33.3% loss
Frame Serialization

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.

Polynomial: 0x1EDC6F41
Undetected Error: P ≈ 2.33 × 10^-10
Background Healing

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.

Benchmark Loss: 10% loss tested
Integrity: 100% bit-exact match

Interactive Responsive Diagrams

Native vector SVG renderings with zero iframes — high contrast, vivid labels, and responsive across desktop and mobile.

High Contrast Vector SVG • High DPI
Zero Iframes • Inline Vector
ALS SubZero System Architecture An architecture diagram generated by Archify. Client Application · CLI / Web / POSIX FUSE · Architecture component Client Application CLI / Web / POSIX FUSE Virtual File System · POSIX Inode Hierarchy · ALS SubZero Storage Node (Core Engine) Virtual File System POSIX Inode Hierarchy Galois Field FEC · Cauchy RS (K=4, M=2) · ALS SubZero Storage Node (Core Engine) · GF(2^8) Galois Field FEC Cauchy RS (K=4, M=2) GF(2^8) Parity Scrubber · Self-Healing Auto-Repair · ALS SubZero Storage Node (Core Engine) Parity Scrubber Self-Healing Auto-Repair Frame Serialization · 24B ALS1 + CRC32C · ALS SubZero Storage Node (Core Engine) Frame Serialization 24B ALS1 + CRC32C Recirculation Pacer · Microsecond Token Queue · ALS SubZero Storage Node (Core Engine) · Target RTT Recirculation Pacer Microsecond Token Queue Target RTT Multi-Transport Layer · Raw ICMP / UDP Echo · ALS SubZero Storage Node (Core Engine) Multi-Transport Layer Raw ICMP / UDP Echo Network Reflectors · Internet WAN / LAN Nodes · Architecture component Network Reflectors Internet WAN / LAN Nodes write / read partition blocks reconstruct chunk encode (K+M) authenticated frames paced dispatch ICMP Echo Req ICMP Echo Reply assemble reads ALS SubZero Storage Node (Core Engine) Legend Frontend Backend Cloud Security Message bus External
Figure 1: Full System Architecture. Client application interacts through POSIX VFS or Web REST console. SubZeroEngine partitions data into Galois Field Cauchy RS matrices ($K=4, M=2$), signs frames with BLAKE2b hashes, applies microsecond pacing, and circulates frames across remote echo reflectors.
ALS SubZero In-Flight Dataflow A data-flow diagram generated by Archify. 01 / Client I/O 02 / Partition & FEC 03 / Pacing & Frame 04 / Network Delay Line 05 / Scrub & Reassemble File Writer · POSIX / Web API · 01 / Client I/O · payload File Writer POSIX / Web API payload File Reader · Slice Lookup · 01 / Client I/O · read File Reader Slice Lookup read Block Slicer · 1024B Chunks · 02 / Partition & FEC · K data Block Slicer 1024B Chunks K data Cauchy RS Codec · GF(2^8) Matrix · 02 / Partition & FEC · M parity Cauchy RS Codec GF(2^8) Matrix M parity Frame Pack · 24B CRC32C · 03 / Pacing & Frame · ALS1 Frame Pack 24B CRC32C ALS1 Pacer Queue · RTT Rate Shaping · 03 / Pacing & Frame · token Pacer Queue RTT Rate Shaping token IP Links · Propagation Path · 04 / Network Delay Line · in-flight IP Links Propagation Path in-flight Reflector Fleet · ICMP / UDP Echo · 04 / Network Delay Line · bounce Reflector Fleet ICMP / UDP Echo bounce Auto-Scrubber · Loss Reconstruction · 05 / Scrub & Reassemble · healer Auto-Scrubber Loss Reconstruction healer Read Assembler · Volatile Assembly · 05 / Scrub & Reassemble · buffer Read Assembler Volatile Assembly buffer write stream data blocks K fragments M parity ALS1 frames paced dispatch echo request echo reply recirculation loss detection reinjected chunk intercept chunk byte slice Legend primary data policy / PII data store data flow
Figure 2: In-Flight Circulation Dataflow. Trace of file bytes through chunking, Galois field Cauchy RS matrix encoding, microsecond rate pacing, reflector transit delay, and active background parity scrubbing.
ALS SubZero In-Flight Recovery Sequence A sequence diagram generated by Archify. write('/file.bin', data) encode(K=2, M=1) frames C0, C1, P0 (ALS1) paced TX (id=1, seq=0) ICMP Echo Request Echo Reply (C0, P0) recirculate C0, P0 missing C1 timeout reconstruct C1 from P0 ^ C0 re-emit healed C1 read('/file.bin') intercept active chunks 200 OK (bit-exact buffer) File Write and Parity Injection Packet Drop and Parity Reconstruction In-Flight Chunk Interception & Read Client App · POSIX / Web / CLI · Sequence participant Client App POSIX / Web / CLI VFS Engine · Inode Table · Sequence participant VFS Engine Inode Table RS Codec · GF(2^8) Erasure · Sequence participant RS Codec GF(2^8) Erasure Pacing Wheel · Target RTT Token · Sequence participant Pacing Wheel Target RTT Token Transport · Raw ICMP / UDP · Sequence participant Transport Raw ICMP / UDP Reflector · WAN Turnaround · Sequence participant Reflector WAN Turnaround Legend main request return security message
Figure 3: Read, Scrubber & Refresh Sequence. Timeline sequence demonstrating asynchronous frame return, in-flight parity reconstruction upon packet loss, and zero-disk write verification.

Capabilities & Practical Limitations

An honest, rigorous breakdown of what the system does and what it does not do.

Engineering Analysis

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.
Click any image to enlarge: Tap or click any proof sheet below to open the high-resolution inspection viewer with page navigation.
Handwritten Mathematical Calculations Cover Page 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.
Notebook Catch: In the initial derivation, omitting the 24-byte header gave 1,220 frames, overpromising capacity by 28 KB. The engine accounts for the full 4,120-byte wire frame.
Handwritten Problem 1 Scan Page 1 Page 1: Link budget & BDP derivations
Handwritten Problem 1 Scan Page 2 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.
Verified in unit test: assert GF_EXP[:13] == [1, 2, 4, 8, 16, 32, 64, 128, 29, 58, 116, 232, 205]
Problem 2 Scan 1Page 1: Polynomial definition
Problem 2 Scan 2Page 2: Generator powers
Problem 2 Scan 3Page 3: XOR overflow steps
Problem 2 Scan 4Page 4: Log/Exp synthesis

Problem 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).
Zero Edge Case: If a = 0 or b = 0, LOG is undefined. Must branch to return 0 before array indexing.
Problem 3 Scan 1Page 1: Log-table multiplication
Problem 3 Scan 2Page 2: Zero-case branch proof

Problem 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.
Problem 4 Scan 1Page 1: Multiplicative inverses and verification

Problem 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]]
Problem 5 Scan 1Page 1: Cauchy matrix construction & symmetry

Problem 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)
Final 6-chunk stripe: [42, 105, 77, 210, 92, 15].
Problem 6 Scan 1Page 1: Input vector & matrix setup
Problem 6 Scan 2Page 2: P0 vector multiplication
Problem 6 Scan 3Page 3: P1 vector multiplication

Problem 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]
Q.E.D. Dropped packets regenerated mathematically with zero bit errors.
Problem 7 Scan 1Page 1: Drop scenario setup
Problem 7 Scan 2Page 2: Submatrix selection
Problem 7 Scan 3Page 3: Pivot elimination
Problem 7 Scan 4Page 4: Submatrix inverse
Problem 7 Scan 5Page 5: D1 & D3 byte recovery

Problem 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
Problem 8 Scan 1Page 1: 24B binary header & polynomial
Problem 8 Scan 2Page 2: Single-bit flip tamper proof

Scientific Research Paper

Full academic preprint describing theoretical foundations, proofs, and empirical tests.

Preprint • 8 Pages • LaTeX • IEEE/ACM Format

ALS SubZero: A Dynamic Delay-Line Network Memory Filesystem with Erasure-Coded Flight Persistence

Samin Sami • Independent Researcher & Systems Engineer • Contact: GitHub | LinkedIn
Abstract: Modern computing systems treat persistent storage as fundamentally non-volatile and localized to solid-state drives or magnetic media. This paper introduces ALS SubZero, an in-flight network delay-line filesystem that stores arbitrary digital file payloads entirely within IP packet propagation transit across computer networks with zero local disk writes (0.0 MB/s disk I/O). By integrating Cauchy Reed-Solomon erasure coding ($K=4, M=2$) over Galois Field $GF(2^8)$, microsecond rate pacing, and active background parity scrubbing, ALS SubZero achieves 100% bit-exact retention across 60 network loops with 0.0 MB/s disk I/O.
ALS_SubZero_Research_Paper.pdf (8 Pages, Academic Preprint) Open Tab Download PDF
Viewing on mobile? Tap below to open the complete document in full-screen reader.
Open Full PDF
BibTeX Citation
@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.

20/20 Unit Tests Passed in 0.75s
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
Swipe horizontally to inspect full benchmark results on mobile

Bandwidth-Delay Link Budget

Total in-flight storage capacity: C = Bandwidth × Round-Trip Time (BDP).

Metro Ring
1 Gbps • 10 ms RTT
1.25 MB in flight
  • 1,250,000 bytes volatile buffer
  • ~303 active 4120B frames
  • Campus LAN / Metro interconnect
  • Zero hard drive / SSD usage
Standard Benchmark
Trans-Continental
1 Gbps • 40 ms RTT
5.0 MB in flight
  • 5,000,000 bytes in motion
  • 1,213 active 4120B frames
  • Cross-country IP path
  • Active Cauchy parity scrubber
Transatlantic WAN
10 Gbps • 80 ms RTT
100 MB in flight
  • 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.

ALS SubZero Interactive Shell
Interactive terminal shell running in-flight commands and live telemetry.
ALS SubZero Localhost Web Console
Real-time web control console on port 8080 with in-flight VFS tree and packet injector.

Quickstart Verification Commands

# 1. Run full unit test suite (20 tests, zero external dependencies) python tests/run_all.py # 2. Launch interactive terminal shell python -m als_subzero.cli.main shell # 3. Start local web dashboard & REST API on port 8080 python -m als_subzero.cli.main serve --port 8080 # 4. Run automated packet loss resilience benchmark python scripts/run_benchmark.py

Interactive Shell Command Reference

Available Commands: ls [path] Show files in dir cd [path] Change dir pwd Print current dir cat <path> Dump file contents from wire write <path> <text> Write text into in-flight file put <local> [remote] Push local file into wire get <remote> [local] Pull in-flight file to disk mkdir <path> Make directory rm <path> Delete file stat <path> Show inode and chunk info tree [path] Show directory tree status | telemetry Show live telemetry & RTT bench [loops] Run loop persistence test serve [port] Start web UI / REST server (default 8080) exit | quit Exit shell

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.

Samin Sami
Author & Systems Researcher

Samin Sami

ALS stands for "Al Sami" (Samin Yasar AL Sami)

Designed and implemented the ALS SubZero in-flight network memory filesystem, formulating the underlying Galois Field arithmetic, Cauchy generator matrices, and microsecond queue scheduling.

Open-source software licensed under the MIT License. Copyright © 2026 Samin Sami.

Technical Queries & FAQ

Does ALS SubZero write zero bytes to persistent disk?
Yes. The engine operates with verified 0.0 MB/s disk I/O. File payloads exist exclusively as circulating IP packet payloads in flight across remote echo reflectors. Data never touches an SSD, hard drive, or USB drive while in flight.
How does Cauchy Reed-Solomon recover dropped packets in flight?
Each stripe consists of K=4 data chunks and M=2 parity chunks. Because every square submatrix of a Cauchy generator matrix is non-singular over GF(2^8), any 4 surviving chunks out of 6 can invert the submatrix via Gauss-Jordan elimination to reconstruct dropped bytes with 100% bit-exact accuracy.
What prevents socket buffer overflow (ENOBUFS) on fast networks?
The microsecond departure rate pacer holds returning packets in a priority queue until their scheduled departure timestamp, enforcing a minimum spacing of 100 microseconds between consecutive packet departures to keep socket queues strictly bounded.
What does ALS stand for?
ALS stands for "Al Sami", taken from the name of the designer and builder: Samin Yasar AL Sami.