LH Luke Hinojosa
Game programmer from Downingtown, PA, studying at Champlain College

Making ideas playable.

I'm Luke Hinojosa, a game programmer who mostly writes C++. I've made multiplayer netcode, an air-defense simulation, and a Minecraft mod that started as a favor for my friends.

See the projects lumahi@proton.me
GitHub LinkedIn
0.44ms per frame to update and re-index 10,000 tracks Defense Simulation
484,564 real Manhattan buildings rendered at 60 FPS Defense Simulation
1,000ms round-trip latency survived without a desync Schrödinger's Pong
83,561 downloads across Modrinth and CurseForge Simple AutoPickup

It started at a book fair.

In fifth grade I picked up Coding Games in Scratch by Carol Vorderman at my school's Scholastic book fair, and that was it. A year later my science fair project was, looking back, my first benchmark: I timed Scratch scripts with a stopwatch to find out whether "walk 2 steps, walk 2 steps" ran slower than "walk 4 steps." I didn't know yet that Scratch throttles its own speed, or what a compiler does. I still like finding out how long things take.

Games were the first kind of programming I knew existed, and they're still why I do this. A good game gives someone somewhere else to be for a while, and I like the idea that something I made turned someone's day into a better one. My favorite part of the work is the moment something I'd only imagined starts actually running.

I grew up in Downingtown, Pennsylvania, outside Philadelphia, and went to Downingtown East. Now I'm studying Game Programming at Champlain College in Burlington, Vermont. In spring 2025 I worked in the Security Operations Center at the Leahy Center for Digital Forensics & Cybersecurity, building an Elastic Stack from scratch for network logs and writing troubleshooting guides for the team. I've kept the habit of writing things down ever since.

Lately I've been driving a mecanum robot from a Meta Quest 2 over a custom UDP protocol with stereo camera passthrough, building GOAP planners and A* pathfinding in Unity, and taking Game Physics and AI for Games.

When I'm not programming, I'm usually still playing something: Minecraft, Rain World, Spore, Super Hexagon, Escape the Backrooms, Arizona Sunshine, and more shooters than I can count. Otherwise I'm catching up on shows, listening to music, or working out.

From
Downingtown, PennsylvaniaDowningtown East High School
Education
B.S. Game Programming, Champlain CollegeExpected May 2028
Honors
Trustees' List & President's List, multiple semestersDean's List, Fall 2025
Experience
Security Operations Intern, Leahy Center for Digital Forensics & CybersecurityFeb 2025 to May 2025
Languages
C++17/20, C#, Java, Python, SQL, TypeScript
Systems
Shared memory (Boost.Interprocess), lock-free seqlocks, TCP/UDP sockets (Winsock, POSIX), WebSockets, WebAssembly
Graphics
Raylib, OpenGL, GPU instancing, Unity, octrees, 3D vector math
Tooling
CMake, GoogleTest, Valgrind, perf, GDB, Docker, Git, Jira, Elastic Stack
Coursework
Linear Algebra, Data Structures & Algorithms, Network Programming, Game Architecture, Software Architecture Patterns

Three things I've built.

Each one started as something I wanted to exist and ended up teaching me something I didn't know yet. The demos run live in your browser.

Real-Time Air Defense & Telemetry Suite

Defense Simulation

A multithreaded engine that tracks hostile missiles, assigns interceptors, and guides them in with Proportional Navigation, then streams every frame to a separate 3D command-and-control display built on a real 1:1 map of Midtown Manhattan.

I wanted to try the kind of work defense engineers actually do, and most of it was past what I knew. I'd never heard of IPC or ProNav, and I'd never used a test framework or a profiler beyond an FPS counter. It began as two separate projects: a missile tracker built on an octree, and two programs sharing memory. Combining them worked, but the tracker had nothing to do with what it tracked. Interceptors gave it a purpose, and learning how they're really guided led me to Proportional Navigation.

C2 TACTICAL DISPLAY
5 MB download · needs WebGL2 · works on phones
The real engine, compiled to WebAssembly. The same C++ raid and guidance code as the native build, stepping a 100-missile raid in your browser over every building in New York City. Drag to orbit, scroll to zoom, click a missile to follow it.Open full page
  • Proportional Navigation with real airframe limits.The command a = N·(Vr × Ω) is capped at the interceptor's G-limit and thrust, so rounds arc through turns instead of pivoting. Convergence is tested against crossing, inbound, and weaving targets for N = 3, 4, and 5.
  • An octree that rebuilds 60 times a second without touching the allocator.Nodes live in one contiguous pool and reset instead of freeing. Profiling on a Pi 4 showed allocator churn was the real cost; pooling cut frame time from 12.3 ms to 6.0 ms and L1 cache misses by 44%.
  • A swept proximity fuze.At Mach 3 closing speeds a round moves about 30 m per frame, so a point check tunnels straight through the target. The fuze tests closest approach across the whole step.
  • Two telemetry transports behind one interface.Locally, a lock-free seqlock ring in shared memory with zero allocation on publish. Remotely, UDP with a zig-zag + VLQ codec that shrinks a 30 B record to about 12 to 15 B, so the entire scene fits in one datagram.
  • My first real test suite and profiler.CMake presets for MSVC and Linux, a data-driven YAML scenario, 61 GoogleTest cases, and a clean Valgrind report: 0 bytes in use at exit.
Frame time, 10,000 entities
0.44ms
Frame time, 50,000 entities
1.6ms
Octree rebuild, pooled vs. linked (Pi 4)
2.05× faster
Building instances at 60 FPS
484,564
Bytes per track on the wire
12 to 15B
Unit tests / leaked bytes
61 / 0
Architecture: one engine, decoupled consumers
defense_simThread pool kinematics at 60 Hz → octree index → ProNav guidance → engagement manager
Shared memorySeqlock ring buffer, zero-copy, local
UDPZig-zag + VLQ codec, remote over Tailscale
ITelemetryConsumerTransport-agnostic interface; one flag picks the source
c2_visualizerRaylib 3D display and HUD
telemetry_monitorConsole threat and rate readout
Rendering and monitoring run in their own processes, so they add zero cost to the engine loop. The same visualizer binary reads a Pi's shared memory locally or a UDP stream on a Windows PC.
Real-time multiplayer, no engine

Schrödinger's Pong

Pong is the simplest game there is, until two players are 500 ms apart. I wrote the networking from scratch in C++: a custom binary protocol, deterministic fixed-point physics shared by native and WebAssembly builds, and a prediction system where the ball splits into every possible future until the other player confirms which one happened.

I knew my Network Programming final would be Pong the moment the class started. Basic online Pong feels awful for whoever isn't the host: you swing and then wait to find out if you hit. Standard multiplayer techniques didn't fix that imbalance, so I decided that in a game this unserious, each player gets to be the authority on their own paddle. That opens a window where the ball could be doing several things at once, and the other player can't know which until the packets arrive. So instead of hiding that, I show all of it, and deterministic physics gives them time to react.

LIVE DEMO · YOU ARE THE GUEST (RIGHT PADDLE) IN SYNC
AuthCollision log will appear here

Watch the left paddle. When the ball reaches the remote host, it splits into miss, up, middle, and down timelines (yellow). The host's AuthCollision message arrives after half the RTT and collapses them. Switch to "Wait for host" to see the teleport this system removes.

  • Determinism by construction.Floating point rounds differently across CPUs, compilers, and WebAssembly, and a one-frame difference snowballs into a desync. The simulation runs entirely in integers at 1/100 pixel, so native and browser clients compute identical trajectories.
  • Phase-locked tick pacing.The guest estimates round-trip time continuously and nudges its simulation clock between 0.99× and 1.01× to track the host, snapping only during the countdown where a jump is invisible.
  • Distributed authority.Each player is authoritative over their own paddle face, which eliminates ghost hits. The Schrödinger ball bridges the gap until the peer's verdict arrives.
  • Beating TCP head-of-line blocking.WebSockets run over TCP, so one lost packet stalls everything behind it. Critical collision messages repeat for 30 consecutive frames instead of waiting on a retransmit.
  • Playable online, for real.A C++ signaling server brokers lobbies over JSON and then relays raw bytes without inspecting them. It ships in a multi-stage Docker image with automatic Let's Encrypt TLS.
Round-trip latency stress-tested
1,000ms
Largest game-state packet
48B
Clock drift correction
±1%
Collision redundancy
30frames
Fixed-point resolution
1/100px
Simulation rate
60Hz
Wire format: GameState packet
Δx = −3 → zig-zag 5 → VLQ 05 (1 byte) Δx = +130 → zig-zag 260 → VLQ 84 02 (2 bytes)
Only fields flagged in the delta mask are sent. Zig-zag encoding maps small negative deltas to small unsigned numbers so variable-length quantities can pack them into a single byte instead of four.
Made for our server, now on everyone else's

Simple AutoPickup

Items and experience go straight into your inventory the moment you break a block or defeat a mob. Simple idea, hard to do right in someone else's engine: it has to credit the correct player, survive every mod that breaks blocks its own way, and keep working as Minecraft changes underneath it.

Two of my friends wanted a mod for our Minecraft server that put items straight into their inventory. I went looking and couldn't find one that did it, so I learned Fabric and Mixin and wrote it myself. It grew from there: more loaders, more versions, and bug reports from people I'd never met.

IN GAME
Chain mining. Every block in the vein is attributed back to the player who started it, with XP.
  • One codebase, sixteen builds.A Gradle multi-project produces jars for Fabric, Forge, and NeoForge across Minecraft 1.12.2 to 26.3, from Java 8 bytecode on the 2017 release to the Java 25 unobfuscated releases. Session tracking, loot splitting, and permissions live in a core module that compiles with no Minecraft types at all, so every version, even the pre-Mojang-mappings 1.12.2, shares one implementation behind thin per-version adapters.
  • Correct attribution through more than a dozen injection points.Mixins track which break is "on the stack," so chain-miners and collapsing bamboo credit the player while automated farms running nearby are never siphoned into their inventory.
  • Game-feel details that players notice.Experience is cached and applied after the tool takes durability damage, so Mending behaves exactly like vanilla. Mob loot and XP can be split evenly among everyone who landed a hit.
  • A three-tier permission model.Server defaults, per-player admin overrides, and client preferences, synced through a hidden command channel that works across mismatched versions.
  • Maintained in public.Bug reports from players drive the roadmap. All 25 GitHub issues are closed, and a public API lets other mods route rewards through AutoPickup.
Downloads, Modrinth
65,035
Downloads, CurseForge
18,526
Minecraft versions supported
13
Mod loaders
3
GitHub issues closed
25 / 25
Latest full week, Modrinth
8,252
Weekly downloads on Modrinth and CurseForge
View as table
Week ofModrinthCurseForge
Weekly downloads from Modrinth analytics and CurseForge's author stats, full weeks through Sep 27, 2026. CurseForge weeks before Mar 20, 2026 are estimated.

Get in touch.

Questions about one of these projects, a game you think I'd like, or something you're building yourself: I'd like to hear about it. Email is the fastest way to reach me.

Email lumahi@proton.me
LinkedIn GitHub