Paul Abrams

Game Systems / Engine Programmer

Focused on deterministic multiplayer, rollback networking, and high-performance simulation systems.

Building scalable systems through deliberate constraints, deterministic execution, and efficient data design.

About

I design and build custom engine systems focused on performance, determinism, and scalability.

My work centers on solving problems that typically limit game systems, especially around multiplayer consistency, large-scale simulation, and runtime overhead.

The goal is to enable more complex and responsive worlds without requiring massive development teams.

Project: Years of Shadow

A custom-built engine and sandbox project focused on large-scale deterministic multiplayer simulation in a voxel-based world.

  • Hybrid lockstep + rollback + replication networking
  • Deterministic simulation using fixed-point math
  • ECS-style data-oriented architecture
  • System-level parallelism with barrier synchronization
  • Custom physics and serialization systems

Repository:
bitbucket.org/dmz22136/yearsofshadow

Networking Architecture

                Player Input
                      │
                      ▼
            Input Synchronization
                (Lockstep)
                      │
                      ▼
        Deterministic Simulation
                      │
         ┌────────────┼────────────┐
         ▼                         ▼
 State History Buffer      Replication Layer
         │                         │
         ▼                         ▼
   Rollback Trigger      Injected State Updates
         │
         ▼
      Rewind
         │
         ▼
   Resimulate Forward
         │
         ▼
      Final State

The system combines deterministic lockstep simulation with rollback-based correction and selective replication.

Rollback Timeline

Time →        100   101   102   103   104

Predicted      A     B     C     D     E
Actual         A     B    C*     D     E
                      ↑ correction arrives

Rewind → 101 → replay → current

Inspired by Overwatch-style networking, adapted for larger-scale simulation beyond typical arena-based games.

Multithreading Model

The engine uses deterministic parallelism at the system level.

  • Each system runs across all cores in parallel
  • Work is distributed across entities
  • A barrier ensures completion before the next system runs

This approach preserves determinism while efficiently utilizing multi-core CPUs and avoiding complex async behavior.

Performance Result

~40,000 NPCs @ 60 ticks per second

Stress test demonstrating large-scale deterministic simulation using parallel ECS systems and lightweight physics.

View 40k NPC Stress Test (Video)

NPCs use lightweight AABB physics bodies in a custom multithreaded physics system.

  • Parallel movement, decision-making, and actions
  • Physics queries for proximity detection
  • No navmesh — behavior emerges from scale

Note: This footage is from an earlier build and includes known issues. Performance characteristics are representative.

Data Design (.ent Files)

Game systems are driven by custom .ent data files.

  • Restricted structure (no deep nesting)
  • Predictable layout for fast parsing
  • Efficient serialization for networking

This keeps data lightweight, reduces indirection, and simplifies system design.

Contact

Email: dmz22136@mail.com