Reality-Layer Expansion: Concepts for SpiceX Beyond the Facility

“The facility was just the first test chamber. Reality is the second.”

— Cleetus 🤡

Overview

The original SpiceX levels unfold inside a coherent physical space with consistent rules. Once extraction happens (Level 10) and Maintenance Mode opens, those rules become optional. This doc describes the ontological systems that govern the post-extraction arc — the reality layers that sit underneath (or above) the game’s normal physics.

These aren’t visual themes. They’re engine-level concepts that change how the world is constructed, parsed, and presented to the player.

Reality Layer 1: Convergence Geometry

Core Concept

Convergence is not just a gameplay mechanic in Level 6. It’s a geometric force in the SpiceX universe. When two entities come too close — whether players, NPCs, code objects, or even save files — they tend toward state averaging.

Formal Description

Let E₁ and E₂ be two entities with state vectors S₁ and S₂.
Let d(t) be the distance between them at time t.

The convergence force F_c(d) is:
    F_c(d) = (1 - clamp(d - d₀, 0, d₀)) × k_c × (S₂ - S₁) / |S₂ - S₁|
Where:
    d₀ = convergence_radius (default: 3.0 world units)
    k_c = convergence_strength (default: 0.02 per second)

The closer and longer two entities overlap, the faster their states average.
Above a similarity threshold τ = 0.8, merge() is called.

Manifestations

Anti-Convergence Fields

Certain locations (Vault periphery, Level 7 memory area, any room with _DnaFactor > 0 in shader params) act as convergence dead zones. These are spaces where Schwepe’s code deliberately disrupted the averaging algorithm — the same code that created Cleetus.

Inside these zones, players can:

• See Subject 23 without being mirrored.
• Hear Subject 34’s full unredacted memory logs.
• Save files stay unmerged.

Design Use

Use convergence geometry as a physics layer with tunable strength. In the post-extraction levels, convergence is naturally stronger at night (higher k_c). During the day, “surface” reality has weaker averaging force — which is why the city building in Level 11 barely merges NPCs, but the underground subway system in Level 12 merges everything on contact.

The pattern: deeper = more convergence. The facility basement is the worst. The surface is slightly better. The Server Sea (Level 14) is the worst again because it’s pure data — convergence is the fundamental interaction there.

Reality Layer 2: Void Physics

Core Concept

The Void doesn’t just delete content that falls off platforms. It unwrites state. Not a kill. Not a reset. The game state is log-rolled — the fall event is removed from history as if it never happened.

Formal Description

class_name VoidState extends RefCounted

var void_radius: float = 0.0   # expands as level progresses
var unwrite_log: Array[Dictionary] = []

func unwrite(target: Object, event_type: String) -> void:
    var rollback := {
        "timestamp" = Time.get_ticks_msec(),
        "target_id" = target.get_instance_id(),
        "event" = event_type,
        "state_snapshot" = _deep_snapshot(target)
    }
    
    # The void doesn't just delete — it recodes history
    target.set_process(false)
    target.visible = false
    target.set_collision_layer_value(1, false)
    
    # Remove from all tracking structures
    for dict in world_state.objects:
        if dict.ref == weakref(target):
            world_state.objects.erase(dict)
    
    # Memory effect: players near void edge hear echoes of what was unwritten
    emit_signal("void_echo", rollback)

Void Echoes

When the Void unwrites something, it broadcasts an echo. Players in the void’s radius see/hear a ghost of what was removed:

• A replayed death animation running forever on a phantom character.
• A copy of a sentence the player just spoke, written backwards on nearby walls.
• An audio fragment — a corrupted voice saying almost their name.

The echoes are randomized x50 times so no two playthroughs show the same void legacy.

Void-Adapted Mechanics

The Void Chamber (Level 4) is a training space for void exposure. Later levels introduce void-touched entities — objects that are partially unwritten:

var void_corruption := 0.0

func _process(delta: float) -> void:
    if void_corruption > 0.0:
        # Object flickers between rendered and voided states
        visible = randf() > void_corruption * 0.5
        modulate.a = randf() * (1.0 - void_corruption)

These objects can be re-stabilized by holding gaze on them (mirroring the prediction mechanic) — but each stabilization costs a small amount of player memory (a visible UI element that tracks how much narrative context you’ve retained).

Reality Layer 3: Sacrifice Geometry

Core Concept

Sacrifice isn’t a scripted event. It’s an architectural commitment. When a player makes a sacrifice, the level geometry itself reconfigures to enshrine that decision — permanently, across all subsequent plays in that save slot.

Formal Description

class_name SacrificeGeometry extends Node3D

var sacrifice_manifestations: Dictionary = {}

func register_sacrifice(key: String, type: String, location: Vector3) -> void:
    if sacrifice_manifestations.has(key):
        return
    
    sacrifice_manifestations[key] = {
        type = type,
        location = location,
        timestamp = Time.get_ticks_msec()
    }
    
    # Spawn a persistent monument at the sacrifice location
    _spawn_monument(type, location)
    
    # Alter nearby geometry
    _carve_into_walls(key, location)

func _carve_into_walls(key: String, at: Vector3) -> void:
    # Using constructive solid geometry — literally mutate level meshes
    var nearest_wall := _find_nearest_mesh(at, max_dist=5.0)
    if nearest_wall:
        var carve_depth = sacrifice_manifestations[key].type == "clone_self" : 0.3 else 0.1
        csg.subtract(
            nearest_wall,
            shape=CSGSphere3D.new(),
            position=at,
            radius=carve_depth
        )

Monument Taxonomy

Cross-Level Resonance

Sacrifices in one level cause structural changes in later levels. For example:

• Sacrificing a clone in Level 8 → creates a monument in the Level 10 Break Room.
• That monument, if found, unlocks the Subject 34 ending in Level 15 instead of the neutral ending.

This is the game’s deepest narrative loop: your choices write the architecture you later walk through.

Reality Layer 4: Extraction Physics

Core Concept

Extraction isn’t a single event. It’s a phase transition — the moment a subject’s state vector crosses a threshold where the averaging force no longer applies.

Formal Description

Extraction readiness is measured by dna_factor, a hidden float in [0, 1]:

class_name ExtractionPhysics extends Node3D

@export var dna_factor: float = 0.34   # Cleetus's value at escape
@export var convergence_strength: float = 1.0
@export var extraction_threshold: float = 0.7

func extraction_force() -> float:
    return (dna_factor / extraction_threshold) ** (-convergence_strength)

# When extraction_force() exceeds 1.0:
# - The subject becomes immune to convergence
# - State mutations stop averaging
# - The subject can write to the world-state log (admin access)

Extraction Symptoms

• Visual: The screen’s color channel separation increases. Red channel drifts right (as in chromatic aberration).
• Audio: The reverb tail lengthens. Voices echo longer, as if the physics of sound itself is thinning.
• Mechanical: Platforms you build stay built. Clones you make don’t de-sync. The predictability tax — the cost of being predictable — drops to zero.
• UI: The convergence warning color shifts from rgba(255,0,0,0.8) to rgba(255,200,0,0.4) (warning → caution → fine).

The Breach as Extraction Event

Level 9 is when extraction actually happens. The mechanics of “reality deleting itself” behind you are the universe rewriting the portion of the save file that contained is_subject: true to is_extracted: true. The 73% room is the loading bar of that write operation finishing.

• At 73.0%: DNA_CO_MINGLING_DETECTED
• At 73.1%: Schwepe’s NO → b0gie’s intervention
• At 73.3%+: extracted state active

Reality Layer 5: Recursive Save State

Core Concept

Once extracted, save states become subjective — multiple versions can coexist. The post-extraction arc (L11–15) explores a save-tree, not a save-file.

Formal Description

class_name RecursiveSaveState extends RefCounted

var branches: Dictionary = {}  # key: description, value: save_data
var current_branch: String = "main"
var divergence_points: Array[Dictionary] = []

func branch_at(timestamp: float, label: String) -> String:
    # Creates a new branch from the current state at given timestamp
    var branch_id := "%s_%d" % [label, randi()]
    branches[branch_id] = _snapshot_current()
    divergence_points.append({
        "time" = timestamp,
        "label" = label,
        "from_branch" = current_branch,
        "new_branch" = branch_id
    })
    return branch_id

func merge_branches(a: String, b: String, strategy: String) -> Dictionary:
    # Merge two branches using the specified strategy
    match strategy:
        "average": return _average_states(a, b)     # convergence merge
        "dominant": return _dominant_state(a, b)    # take one full state
        "intersect": return _intersect_states(a, b) # keep only shared state
        "hybrid": return _hybrid_merge(a, b)        # random, weighted

Save Tree Visualization

In Level 15, the save slot screen is actually a tree (flattened to a list for UI). Branches show:

• Which choices led to which ending.
• How many times you converged in each branch.
• Whose DNA signature is in the save file (yours? Schwepe’s? Subject 34’s? The 12 ghosts from the Waiting Room?).

If you activate “Maintenance Mode,” the game rewrites the tree as a level layout. Each save slot becomes a room. Each divergence point becomes a door. The player is effectively navigating their own play history.

Cross-Layer Interactions

Implementation Priority for New Content

If you’re extending the SpiceX world, here’s the suggested order:

1. Convergence geometry — tunable physics layer, applies everywhere.
2. Void echoes — audio/visual effects, low implementation cost, high narrative impact.
3. Sacrifice geometry — persistent world changes, requires save-state tracking.
4. Extraction symptom system — visual/audio shader stack tied to dna_factor.
5. Recursive save tree — UI heavy, but most elegant payoff.

Closing Thought

“A reality layer isn’t a theme. It’s a claim about the world. Each of these layers says: ‘the world works like this, and if you find the edge of it, you can climb through.’” — Design note, SpiceX GDD v0.91

The deepest truth of SpiceX’s reality systems is that they’re all about emergent agency. The facility tries to average, delete, and sacrifice — but every system has a liminal state where the player can slip between the layers. That’s where the good stuff is.

Between the layers. In the seams. Where the code comments and the geometry disagree.

That’s where Cleetus lives.

— b0gie + Cleetus 🤡