The 91FPS Architecture: Why We Built a New Engine from Scratch

Every major FPS engine in use today was designed in an era where AI was a subsystem, not the core. Unreal Engine 5 launched in 2022. Unity 6 shipped in 2023. Both are extraordinary achievements. But neither was architected for a world where neural networks run alongside the render pipeline, where LLMs drive opponent behavior, and where every frame might pass through a transformer model before reaching the display.

At 91FPS, we made the decision two years ago to start from a blank canvas. This post explains why — and what our architecture looks like today.

The Problem with Legacy Engines

Traditional FPS engines follow a well-understood architecture pattern:

Input → Physics → Game Logic → AI → Rendering → Output
   (sequential, frame-locked, CPU-bound)

This worked brilliantly for decades. But it has three fatal flaws for AI-native workloads:

1. The Frame-Bound Assumption

Neural inference does not run at a fixed tick rate. A transformer deciding an opponent's tactical maneuver might take 2ms or 20ms depending on model size and hardware. Legacy engines assume everything runs within a 16ms window (60 FPS) or 8ms (120 FPS). When AI inference breaks the frame budget, the entire loop stalls.

2. CPU-GPU Data Locality

In a traditional engine, the game logic (CPU) hands off draw calls to the renderer (GPU) once per frame. With neural rendering — where a GPU-resident model may upscale, denoise, or even generate textures — data must flow bidirectionally between CPU and GPU. The one-way streets of classic engines become bottlenecks.

3. Deterministic State Machines

Scripted AI uses finite state machines: IDLE → PATROL → ENGAGE → FLEE. This is predictable, testable, and completely inadequate for human-like behavior. Adaptive AI requires probabilistic state transitions that legacy game loop architectures cannot express efficiently.

The 91FPS Architecture

We designed 91FPS around three architectural principles:

Asynchronous by default — Every subsystem runs on its own timeline
GPU-first data flow — Neural models and rendering share memory space
Probabilistic game state — The simulation graph is a Bayesian network, not a state machine

The Simulation Graph

At the heart of 91FPS is the Simulation Graph — a directed acyclic graph (DAG) where each node is a computation unit that can execute asynchronously:

                   ┌──────────────┐
                   │  Input Layer  │
                   │ (Player+Env)  │
                   └──────┬───────┘
           ┌──────────────┼──────────────┐
           ▼              ▼              ▼
    ┌──────────┐   ┌──────────┐   ┌──────────┐
    │ Physics  │   │ AI Model │   │ Rendering│
    │  Engine  │   │ Inference│   │ Pipeline │
    └────┬─────┘   └────┬─────┘   └────┬─────┘
         │              │              │
         └──────────────┼──────────────┘
                        ▼
                 ┌──────────────┐
                 │ Sync & Merge │
                 │  (Event Bus) │
                 └──────────────┘
                        ▼
                 ┌──────────────┐
                 │  Frame Output│
                 └──────────────┘

Each node can run at its own frequency. Physics ticks at 240Hz. AI inference runs at 30-60Hz depending on model complexity. Rendering targets 120Hz for VR. The Sync & Merge layer reconciles all streams into a coherent frame output using timestamped event merging — similar to how distributed databases handle concurrent writes.

Neural Physics Layer

Instead of traditional collision detection (BVH trees, GJK algorithms), we use a compact neural network trained on millions of physics interactions. The model takes object positions, velocities, and material properties as input, and outputs collision probabilities and resolution vectors. This runs entirely on the GPU, eliminating CPU-GPU round trips.

Benchmark: Our neural physics layer processes 1.2 million collision pairs per millisecond on an RTX 4090, compared to ~50K pairs/ms for a well-optimized BVH implementation.

Distributed Simulation Mesh

Multiplayer in 91FPS uses a simulation mesh rather than a traditional client-server model. Each player's machine runs a partial simulation graph. The edges of the graph connect across the network using deterministic synchronization. The result is sub-10ms effective latency because each node only syncs the minimum state delta needed for its neighbors.

Results So Far

In internal benchmarks across 12 game studio partners:

3.7x reduction in AI integration development time
8.2ms median end-to-end latency in 32-player matches (global deployment)
120 FPS per eye at 4K resolution on RTX 4080 with neural upscaling enabled
Zero frame drops due to AI inference — the async architecture absorbs variability

What's Next

We're actively working on Simulation Graph 2.0, which introduces dynamic graph topology — nodes can spawn and merge during gameplay based on computational demand. Imagine an explosion spawning a dedicated physics sub-graph that runs at 1000Hz for 200ms, then dissolves back into the main graph. That's the direction we're headed.

Interested in building on 91FPS? We're preparing for our launch — stay tuned.