Burrito’s Labs Indie Tech Outmost Studio
Games & Simulations
Active development

Cellular Siege

A portrait strategy game where the player grows a cellular defense, then protects or cuts it as invading bugs spread corruption through the same organism.

Category
Games & Simulations
Platform
iPhone · iOS 17+
Status
Active development

What if the battlefield were cultivated rather than constructed?

Seeded circuit boards, deterministic cellular growth, infection, direct touch tools, and short wave runs turn tower defense into the care of an unstable organism.

User value

Grow the defense. Cut it before it turns.

Cultivate a living mold around the circuit path while bugs convert the same defense into spreading corruption.

01

Shape a living defense

Seed cellular growth where it can reach the path instead of placing permanent towers on fixed slots.

02

Contain your own organism

Protect valuable regions with Serum or cut away healthy and infected tissue before corruption spreads farther.

03

Read and retry quickly

Use short portrait runs, clear energy and core states, deterministic seeds, and immediate restart to learn the system.

Staged Cellular Siege pixel-art board showing an orange circuit path, yellow bugs, green and red mold, a protected cell, a core, and Seed, Cut, and Serum controls.View full size
Phase 2 visual targetA code-rendered staged prototype, not a gameplay run or final production interface.

Features

A living-defense playable slice.

The current debug preview connects the central simulation, enemies, tools, resource economy, and run outcome.

  1. 01

    Generated circuit boards

    Build a validated path from a deterministic seed and fall back to known-safe maps when generation fails.

  2. 02

    Growth and corruption

    Spread healthy mold under cellular rules, damage bugs on contact, and watch infection move through the colony.

  3. 03

    Seed, Cut, and Serum

    Start new growth, remove organism cells without damaging terrain, or protect a healthy region temporarily.

  4. 04

    Three enemy foundations

    Basic, Glitch, and Heavy bugs move along the circuit path during a provisional three-wave sequence.

  5. 05

    Run economy and outcome

    Spend energy, use free seeds, earn enemy rewards, protect three core lives, and finish in a frozen win or loss state.

  6. 06

    Code-defined pixel presentation

    Render the 160 by 256 canvas, font, sprites, circuit path, effects, controls, and CRT treatment from code.

How it works

Cultivate, defend, contain.

The current debug slice begins with a warm-up, then advances through three deterministic waves.

  1. 01

    Generate the circuit

    Create a seeded board with a validated path, playable regions, and a core at the end.

  2. 02

    Prepare during warm-up

    Inspect the board, test the three tools, and place initial growth before the first wave begins.

  3. 03

    Seed useful contact zones

    Spend a free use or energy to start mold near positions that can damage passing bugs.

  4. 04

    Read the infection

    Watch enemy contact create red corruption that can travel through the same healthy colony.

  5. 05

    Protect or amputate

    Apply Serum to preserve a valuable region or drag Cut through tissue to contain a larger threat.

  6. 06

    Resolve and restart

    Clear the final preview wave or lose all core lives, inspect the run metrics, and tap to retry the seeded slice.

Product concept

The defense is also the risk.

Healthy mold is a weapon, shield, resource, and potential route for the corruption that can destroy it.

01

Cultivate instead of place

The player shapes an evolving organism rather than arranging a permanent set of static towers.

02

Touch belongs to the fiction

Seed encourages growth, Serum preserves it, and Cut accepts local loss to contain a wider failure.

03

Emergence remains readable

Seeded randomness, fixed update order, explicit states, and short runs make the changing board learnable and reproducible.

Architecture

Pure Swift rules beneath a pixel renderer.

The simulation remains independent from SpriteKit so maps, cellular behavior, enemies, tools, and run outcomes can be tested without a scene.

  1. 01Touch mapped to virtual canvas
  2. 02Validated player action queue
  3. 03Fixed deterministic simulation tick
  4. 04Growth, corruption, waves, and contact
  5. 05Events, metrics, and run state
  6. 06Pixel buffers and SpriteKit textures

Simulation owns the rules

Pure Swift types manage the board, map, organism, enemies, waves, resources, scoring, and result state without importing SpriteKit.

Terrain and organism stay separate

Cut can remove mold above a path or core without destroying the terrain that defines movement and the objective.

Determinism supports tuning

A seeded generator, fixed five-tick-per-second rate, and explicit update order make diagnostic scenarios reproducible.

The current boundary is local

The source contains no network, account, backend, analytics, advertising, in-app purchase, Game Center, or cloud-save path.

Technology

A deterministic native game stack.

Application

  • Swift
  • SwiftUI
  • SpriteKit
  • UIKit
  • iPhone portrait

Simulation

  • Pure Swift
  • 5 fixed ticks per second
  • Seeded maps
  • Deterministic update order

Rendering

  • 160 × 256 virtual canvas
  • Pixel buffers
  • Nearest-neighbor textures
  • Code-defined sprites and font

Local state

  • Codable save model
  • UserDefaults scaffold
  • No current app-shell integration

Validation

  • XCTest
  • Deterministic gameplay probes
  • Architecture guardrails
  • UI launch test

Development

The central loop works as a debug slice.

Generated maps, cellular growth, corruption, enemies, three tools, energy, core lives, provisional waves, result states, and restart are integrated. Release builds still show a black canvas, and production flow, final content, persistence, audio, balancing, comfort settings, and device validation remain incomplete.

Stage
Active development
Playable scope
Debug-only slice
Preview structure
3 waves
Fresh test run
Not completed

Implemented

  • Portrait SwiftUI and SpriteKit shell with a 160 by 256 nearest-neighbor virtual canvas
  • Pure Swift deterministic simulation, seeded circuit generation, validation, fallback maps, and fixed update order
  • Healthy mold growth, corruption spread, enemy movement and contact, core damage, and wave scheduling
  • Seed, Cut, and Serum controls with action validation, energy costs, free uses, cooldowns, and rewards
  • Basic, Glitch, and Heavy enemy foundations plus provisional progression, metrics, win, loss, and restart
  • Code-defined font, sprites, HUD, controls, effects, CRT treatment, diagnostics, guardrails, and persistence scaffolds

Production transition

Connect the accepted slice to title, tutorial, pause, settings, and result routing; finish the five-wave structure and boss; integrate local saves and comfort settings; add audio and haptics; then validate controls, balance, readability, and performance on iPhones.

Cellular Siege lab notes

The project, over time.

Notes about the thinking, architecture, development, and decisions behind this work.

  1. Cellular Siege
    25 Jun 2026 · Draft

    The Systems Meet in a Playable Slice

    Seed, Cut, Serum, enemies, corruption, energy, core lives, and results became one reproducible three-wave debug run.
  2. Cellular Siege
    8 Jun 2026 · Draft

    From Visual Target to Living Board

    The staged pixel board became seeded map data that later mechanics could grow across, defend, and corrupt.
  3. Cellular Siege
    3 Jun 2026 · Draft

    Building the Native Foundation

    A native SwiftUI and SpriteKit shell, fixed pixel canvas, and deterministic simulation boundary established the game's technical form.