Public · Procedural strategy
Defend
A physics-driven strategy game where the same finite energy is health, construction budget, defended resource and economic consequence—making every defensive decision a trade-off.
- Niche
- Systemic tower defense / physical strategy
- Core stack
- TypeScript · Babylon.js · Rust/WASM experiments
- Design
- Closed economy · temporary infrastructure · physics
- Status
- Playable historical build + modernization program
The niche
Defend replaces path-following tower defense with a physical battlefield that can be shaped, delayed and manipulated.
Mass, momentum, collision, obstruction, knockback, gravity and time are tactical variables. An attacker does not always need to be destroyed; it can be delayed until its finite life expires, redirected, trapped or pushed off the arena.
What is different
One resource connects the entire game.
The resource being protected is also health, building budget, combat recovery and eventually strategic operating cost.
Finite-lived raiders make delay and route shaping legitimate strategies alongside damage.
Towers buy periods of control rather than creating a permanently solved fortress.
The campaign is designed to invert the player’s relationship to the same economy rather than explain the change primarily through exposition.
Product & design thinking
The world should explain itself through motion, geometry, sound and visible resource flow before it reaches for text.
The project deliberately prefers continuous physical trade-offs to opaque type bonuses and immunity tables. The player should be able to infer why something worked by watching the system respond.
That principle also guides progression: stronger defenses create capability, but because they consume the same finite resource they never become free power.
Development approach
Modernization is not allowed to erase the mechanics that make the game itself.
The historical Babylon.js build remains available as the behavior reference while deterministic Rust code, Storybook laboratories and hybrid Babylon/Bevy experiments prove individual contracts. Rendering, gameplay architecture and balance changes are kept separable where practical.
The direction is intentionally hybrid: keep browser presentation where it works, introduce Rust/WASM where determinism, testing, portability or performance justify it, and promote experiments only when evidence supports replacing established behavior.