[ PHASE 01 — ENTRY ]

16.6 milliseconds.

That is the entire budget. Every frame.
Physics. AI. Rendering. Audio. All of it.

Systems & Multiplayer Engineer

scroll
[ PHASE 02 — SYSTEM REALITY ]

Performance is not optional.

Most engineers build features.
I optimize the systems underneath them.

The constraint is what reveals the engineer.
Cache misses. Thread contention. GPU stalls.
These are not edge cases. They are the environment.

16.6ms per frame budget
64B cache line size
~1ns L1 cache latency
cache coherency simulation
[ PHASE 03 — TURNING POINT ]

I stopped asking 'does it work?'

Early on, I built systems that functioned. They passed tests. They compiled. They shipped.

Then I started asking: why is this slow? Where is the bottleneck? What does the profiler say? The answer was always the same — data layout.

That shift — from feature-builder to systems engineer — is what this portfolio is about.

01
[ SIMULATION / C++ ]

Swarm Simulation

Performance is driven by data design, not just algorithms.
Problem
Simulate thousands of entities at real-time framerates
Constraint
Fixed 16.6ms frame budget, single-threaded update loop
Approach
SoA memory layout, spatial partitioning for neighbor queries
Trade-off
Reduced flexibility in entity composition for cache coherency
Key Insight
Memory access patterns dominate over algorithmic complexity
→ View Source
entity field simulation
02
CLIENT
SERVER
Δt = 48ms → compensated: 0ms
[ NETWORKING / DISTRIBUTED SYSTEMS ]

Multiplayer Architecture

Multiplayer is a networking problem, not just a gameplay problem.
Problem
Synchronize game state across clients with unpredictable latency
Constraint
No authoritative server — peer-to-peer with host authority
Approach
Client-side prediction, server reconciliation, lag compensation
Trade-off
Increased complexity in state rollback vs. smoother player experience
Key Insight
Determinism is the prerequisite. Without it, reconciliation is impossible.
→ View Source
03
[ SYSTEMS / CUDA / HIP / SYCL ]

GPU-Accelerated Query Engine

Data flow dictates performance. The bottleneck is always the bus.
Problem
Execute SQL-like queries on columnar data at GPU throughput
Constraint
Vendor-agnostic across CUDA, HIP (AMD), and SYCL (Intel)
Approach
Typed columnar storage, warp-shuffle reduction, lock-free hash join
Trade-off
Portability layer adds abstraction overhead vs. native vendor performance
Key Insight
Memory layout and kernel occupancy matter more than algorithm choice
C++ CUDA HIP/ROCm SYCL Apache Arrow Lock-free Hash Table
→ View Source
SQL Parser
Column Filter
Stream Compaction
Hash Join
Result
[ PHASE 05 — CONFLICT ]

A system that performs well but isn't engaging is still incomplete.

I know where the bottlenecks are. I know how to eliminate them. What I am actively building is the other half — game feel. The screen shake. The audio cue. The 80ms of anticipation before impact. The code that makes a player lean forward.

STRONG
  • Data layout
  • Memory optimization
  • Distributed state
  • Throughput
BUILDING
  • Haptic feedback design
  • Audio synchronization
  • Player psychology

Self-awareness is the beginning of growth.

[ PHASE 06 — TRAJECTORY ]

What I am building next.

Not finished. In progress. Intentional.

IN PROGRESS

Custom C++ Engine

Low-level rendering ownership. Independence from commercial engines.

IN PROGRESS

Authoritative Multiplayer Server

Production-grade distributed architecture. Not a tutorial clone.

IN PROGRESS

Behavior Tree AI System

Intelligence layer. Decision systems beyond state machines.

IN PROGRESS

Game Feel Optimization Layer

Bridging engineering with player experience. The missing half.

[ PHASE 07 — IDENTITY ]

I build systems that scale. Now I'm building systems that feel alive.

→ GitHub · → Contact

Available for internship and full-time roles — Engine, Multiplayer, Systems