Single-Δ Universe, a deterministic, asset-free world generator in which an entire simulation is recoverable from a single seed—as small as the state encoded by a 1×1 pixel. Worlds (geometry, motion, agents, and UI signals) are not stored; they are reconstructed by pure functions from the seed. The core of the system is an anti-zero echo law (“Single-Δ”) clocking a compact pipeline: seed → features → 4D fold → projection → field dynamics. We provide a language-agnostic specification, a portable seed packet, and reference algorithms drawn from working prototypes: (1) a Δ-tesseract engine (4D rotations / 4D→3D→2D projection) and (2) a terrarium engine (slime-mold/predator agents and field flow). The same math runs in the browser, native apps, or embedded, including a 1×1 iframe demo proving that a visible pixel can be the whole “universe.”

1. Motivation

Traditional worlds ship gigabytes of meshes, textures, and authored behavior. Procedural engines reduce this, but still rely on asset graphs and toolchains. Single-Δ Universe pushes further:

• Storage → Math: Replace assets with deterministic transforms.

• Content addressability: The seed is the address; identical seeds produce identical worlds.

• Universality: A pixel (or 32–64 bit value) is sufficient to reconstruct the world.

• Portability: The math predates and transcends any particular language or framework.

2. System Overview

2.1 Deterministic seed

A seed is derived from user input (phrase, color, binary) using a fast 32-bit non-cryptographic hash. Implementations use FNV-style or similar, paired with a small PRNG (e.g., Mulberry32). Both are present in the reference engines.

hash32(s): h ← 2166136261 for c in s: h ← (h ⊕ c) · 16777619 // 32-bit return h rng(seed): 32-bit Mulberry32

2.2 Single-Δ law (anti-zero echo)

A global 1-bit state A is driven toward a measured bit B. To avoid stalling, if Δ = B − A = 0, flip A; else set A ← B. This produces a robust two-phase clock that never “sticks”—a core property across our engines.
Law:

• if Δ=0⇒A←¬A\Delta = 0 \Rightarrow A \leftarrow \lnot AΔ=0⇒A←¬A

• else A←BA \leftarrow BA←B

This rule gates LOD transitions, color/phase, and torque for cog/agent systems in the implementations.

2.3 Geometry kernel (4D base, folding, projection)

• Base lattice: 4D hypercube (tesseract) with 16 vertices.

• Rotations: Fixed small-angle blends across XY/XZ/XW/YZ/YW/ZW planes.

• Fold: Iterated inversion-blend about radius rrr with mix α\alphaα and compaction by master multiplier mmmmmm.

• Projection: 4D→3D→2D4D \to 3D \to 2D4D→3D→2D with perspective divisors.
  These exact operators are implemented in the phrase and terrarium engines.

Fold step (one iteration over point p∈R4p \in \mathbb{R}^4p∈R4):

p′←(1−α)p+αr2∥p∥2p,p′←p′(1+1mm)(1+compact)p' \gets (1-\alpha) p + \alpha \frac{r^2}{\lVert p \rVert^2} p, \quad p' \gets \frac{p'}{(1 + \frac{1}{mm})(1+{\sf compact})}p′←(1−α)p+α∥p∥2r2​p,p′←(1+mm1​)(1+compact)p′​

Repeat depth ddd.

2.4 Feature sourcing

The seed transforms into small offsets/features that modulate the 4D base before folding. We provide two canonical sources:

1. Seed-only offsets: sinusoidal perturbations scaled by RNG; stable and cheap.

2. Data-driven features: CSV statistics → 4D feature vector → offsets. (Means, quantiles, spread.)

2.5 Δ-driven dynamics

A Δ processor emits a motion/LOD signal by analyzing blockwise changes (e.g., from synthesized PCM or any evolving stream). It computes a sign grid, repairs L/C/R inconsistencies, and derives Δ-density, which drives LOD and inversion mix.

2.6 Agent field (optional)

A lightweight agent model (“slime/predator”) runs atop the geometry field: flow vectors, nearest-food pursuit, growth by intake, damping. Entirely seeded; zero assets.

3. Reference Implementations

3.1 Δ-Tesseract Single Engine

A minimal canvas engine rendering a rotating/folding 4D tesseract wireframe, with the anti-zero Δ law controlling edge color/phase and frame evolution. It shows how a single bit law can pace a whole scene.

3.2 Terrarium Hash Engine (Single-Δ + Learning)

A more elaborate engine supporting:

• hash/CSV inputs → feature offsets,

• Δ-law gating,

• learning memory (concept → feature mean/sigma),

• and terrarium visualization.

3.3 Phrase → Universe (Single-Δ Fold Engine)

A single-file demo that converts phrases → deterministic PCM → Δ map to drive geometry (LOD/rotation) and exports a short recording. It includes the fold and projection code above.

3.4 Sandbox & Lake (Executable Prototypes)

“Lake/Sandbox” prototypes integrate Δ metronome, Euclidean gait, triangle gate, and higher-level “cognitive” overlays (Cook+Betts/Bernard/Mahkesis). These demonstrate how systemic behaviors can remain seed-addressable while being richly instrumented.

4. One-Pixel Universe Architecture

4.1 Claim

A single visible pixel (e.g., a 1×1 iframe) is sufficient to (a) carry the seed and (b) prove ongoing evolution by encoding the state’s signature in its RGB value each frame. The world is reconstructed externally from the same seed. (Parent window for “reveal”; child pixel runs headless.)
This design follows our Δ-law and seed/RNG used in the engines.

4.2 Protocol

• Child (1×1): derive seed = hash32(phrase). Evolve A,B,ΔA,B,\DeltaA,B,Δ. Create signature = f(seed, A, flips, ⌊t·fps⌋) and set backgroundColor = rgb(sig0,sig1,sig2). Post a tiny telemetry frame with {seed,A,B,flips,t,signature}.

• Parent: uses the same fold+projection to render a full scene for “reveal,” proving the pixel contained the whole universe (as seed+law).

5. Specification (v0.1)

5.1 Seed packet (.single-delta.seed)

Binary, 16 bytes (example):

FieldSizeNotes

magic “SD1”3version gate

version10x01

seed324hash32(phrase)

profile1renderer profile (0=tesseract, 1=terrarium, etc.)

options3bit flags (A/B policy, LOD mode…)

time324initial tick (frames or ms)

5.2 Determinism requirements

• Identical seed packets must produce identical geometry and agent behavior for any conforming implementation (within float tolerances).

• Hash & RNG must match reference bit-for-bit.

• Δ-law must be applied once per tick before geometry render.

5.3 Geometry reference (Tesseract profile)

• Base V4: 16 vertices at {−1,1}4\{-1,1\}^4{−1,1}4.

• Rotations & projection constants as in §2.3.

• Fold parameters: α∈[0,1],r≈2.0,mm=72\alpha \in [0,1], r\approx2.0, mm=72α∈[0,1],r≈2.0,mm=72.

5.4 Δ-processor (optional)

• Sign grid from PCM blocks with hysteresis ε (% of RMS), bins per block, Δ threshold th. Output: Δ-density and a boolean motion mask. Values drive LOD and inversion mix.

5.5 Agent profile (Terrarium)

• Particles seek nearest “food” in a flow field; growth on intake; damping; seeded hues. Parameters are fixed functions of seed.

6. Algorithms (pseudocode)

Single-Δ tick

B ← measure_bit(t) // e.g., sign of oscillator/projection if B == A: A ← ¬A // anti-zero echo else: A ← B

(Used in both phrase and terrarium engines.)

Offsets from seed

R ← rng(seed) for each vertex v in base4: for k in 0..3: v[k] ← v[k] + amp*(R()*2-1)*sin(i*0.7 + k*1.11)

 

Fold iteration

for i in 1..depth: f ← (r*r)/(dot(p,p)+1e-8) p ← (1-α)*p + α*(f*p) p ← p / ((1+1/mm)*(1+compact))

 

Projection

// 4D→3D sw = 1/(d4 - k4*w); (x,y,z) = (x*sw, y*sw, z*sw) // 3D→2D s3 = 1/(d3 - 0.8*z); (u,v) = (x*s3, y*s3)

 

7. Demonstrations

1. Δ-Tesseract: Wireframe world where Δ flips drive color/phase; no assets.

2. Terrarium (Hash/CSV/Learning): Feature-driven offsets; Δ-law pacing; concept memory.

3. Phrase→Universe: Phrase→PCM→Δ map drives LOD and fold; recordable canvas.

4. One-Pixel Iframe: Pixel encodes signature/seed; parent reconstructs world (spec §4). (Design aligns with the above algorithms.)

8. Performance, Scaling, Compression

• Runtime: Per-frame cost is O(V⋅d)O(V·d)O(V⋅d) for vertices V and fold depth d; edges are linear; agent field is O(N)O(N)O(N) with small radii queries (grid hashing can make it near-linear).

• Compression: A single seed packet (≤16B) replaces gigabytes of assets. Effective “compression” is bounded only by the complexity of functions; reconstruction time is the trade-off.

• Streaming: No network I/O beyond the seed/telemetry. Recording is optional.

9. Interoperability

• Browser (Canvas/WebGL): Current reference implementations.

• Native/Engines: Unity/Unreal/Metal/Vulkan: port the same hash/RNG, Δ-law, fold & projection.

• CAD (optional): The 3D projection points can be surfaced/meshed for CAD exchange; the method is language-agnostic even if later piped into OCC/STEP exporters.

• Data exchange: .single-delta.json (Δ deltas + sample rate) is already supported by Phrase→Universe for reproducible Δ-drives.

10. Correctness, Integrity, and Reproducibility

• Bit-exact determinism: Reference constants for rotations, fold parameters, and Δ-law order are normative.

• Verification: Signature = F(seed, A, flips, t) enables attestation that a renderer conforms to the spec when given a seed.

• Security: Hash/PRNG are not cryptographic; do not use for security purposes.

11. Limitations & Ethics

• “Creatures with thoughts” are simulated agents; they do not constitute sentient minds.

• Floating-point drift across platforms may create slight visual divergence; guidance will specify tolerances and canonical constants.

• Δ-processor inputs (e.g., PCM) are optional; deterministic seeds alone are sufficient.

12. Roadmap

• v0.2 Seed Packet Finalization: finalize fields & reference tests.

• Conformance Suite: golden images for Δ-tesseract & terrarium at fixed seeds.

• One-Pixel SDK: tiny runtime (≤3 KB min+gzip) for iframe/embedded.

• Engine Bridges: Unity/Unreal components using the same math.

• Pixel-Atlas Demo: an image where every pixel is a universe; hover to unfold.

13. Glossary

• Single-Δ (anti-zero echo): If B==AB==AB==A then flip AAA; else A←BA \leftarrow BA←B. A minimal non-stalling update law.

• Fold: Iterated inversion-blend in R4\mathbb{R}^4R4 with compaction.

• Δ-processor: Block/bin sign analysis + repair to produce Δ-density driving motion/LOD.

• Seed offsets: RNG-modulated sinusoidal 4D vertex perturbations.

14. Implementation Checklist (for adopters)

• Implement hash32 and Mulberry32 exactly as specified.

• Implement the Single-Δ update; call it once per tick before rendering.

• Port the 4D base/rotations/projections with the given constants.

• Implement fold with α,r,mm,compact\alpha, r, mm, compactα,r,mm,compact parameters.

• For agent mode, add the slime/predator loop (nearest-food, flow, damping).

• (Optional) Add Δ-processor to drive LOD/inversion speed.

Appendix A — Minimal Seed-Only Renderer (language-agnostic pseudocode)

seed = hash32(input) R = rng(seed) A = 1; B = 0 // precompute offsets for v in base4: v ← v + offset_from_seed(R) // main loop while running: t += dt B ← signbit(oscillator(t, R)) // choose a stable probe if B == A: A ← not A else A ← B // Single-Δ pts ← [] for v in base4: p ← fold(v + offset, depth, α, r, mm, compact) pts.append(project4to2(project4to3(rotate4(p, t)))) draw_wireframe(pts, color = A ? green : red)

(Parameters/rotation constants as in §2.3.)