PROGRAMMING PORTFOLIO

Blake Bentley

I build VR games, backend services and reverse-engineering tools in C#, C++, Python and Kotlin. I care about understanding how systems work and making them harder to break.

I like taking systems apart and building better ones. Most of my work is VR: gameplay and netcode in Unity, native and Kotlin apps on Quest, and the backend services that sit behind them.

I also write Windows tools for inspecting how software behaves, from memory editors and network proxies to a small decompiler. Below are the projects, what I built in each, and the bugs that taught me the most.

01 / FOUNDATIONS

What I stand on

Programming

C#, C++, Python, Kotlin/Java and Lua/Luau. I pick the language the platform wants: C# for Unity and Windows tools, C++ for native and Unreal work, Kotlin for Quest apps, Python for services.

Systems thinking

Games, backends and headsets are many parts talking to each other. My work spans client, network and server, from Photon and PlayFab to Android and OpenXR.

Security mindset

I audit my own code. On my game backend I found hardcoded secrets, plaintext password storage and race conditions, then fixed the races, duplicate grants and trust in raw tokens.

Tooling & UX

I build the tools I wish existed, then give them a consistent design language so they’re pleasant to use, not just functional.

Learning by taking apart

Reading unfamiliar code, debugging unfamiliar platforms (Android, OpenXR, Unreal) and iterating until it works.

Debugging

Bugs I’ve traced to the root in my MITM proxy: an NCSI check silently bypassing the proxy, a broken HTTPS decrypt mode, and missing network timeouts that let dead connections hang the whole tool.

Responsible disclosure

When I find a bug that affects other people’s accounts or data, I report it rather than use it — see Security research below.

02 / PROJECTS

Case studies

UnityC#Photon FusionPlayFabQuest

Nova — zero-gravity VR game

A multiplayer VR game with a zero-gravity disc sport, built for Meta Quest.

  • Locomotion: three-tier grip system (slide, brake, climb), swimming physics, paddle locomotion, gravity zones and velocity tracking.
  • Gameplay: grabbable zero-gravity disc with throw, trail and haptics; hand colliders that physically hit the ball.
  • Networking: separate Photon Fusion apps per region (US, UK, OCE) plus shared Photon Voice, switched at runtime.
  • Custom server (in progress): migrating off Photon to my own C# game server, Flask auth backend and admin dashboard (next card).
  • Level editor: placed objects saved as JSON to PlayFab, restricted to an allow-list of users.
  • Challenges solved: a Kotlin library conflict in the Android build, and a shader rendering pink because of a render-pipeline mismatch.
PythonPyTorchCUDATransformers

MiniAI — a code language model from scratch

A decoder-only transformer I wrote from first principles in PyTorch, meant to be trained on code rather than general text.

  • Tokenizer: my own byte-pair encoding implementation, trained on whatever corpus you feed it, no pretrained vocab.
  • Architecture: grouped-query attention with RoPE position embeddings, SwiGLU feed-forward blocks, RMSNorm, and weight-tied output head — the same building blocks modern small language models use.
  • Presets: small/medium/large/xl configs (128 to 1024 dim, 4 to 16 layers), picked automatically by whether CUDA is available.
  • Data ingestion: an interactive CLI that trains on a URL, a crawled site, a single file, a whole folder of source code, or a column out of a Parquet dataset.
  • Inference: standard sampling plus a self-implemented speculative decoding path (small draft model proposes tokens, the full model verifies them in a batch) that reports acceptance rate and tokens/sec.
  • Checkpointing: safetensors weights plus a JSON config, with auto-save during training and the option to resume and keep training later.
C#UDPPythonFlaskWinFormsPowerShell

Nova server stack

A from-scratch multiplayer backend for Nova: a dedicated game server, an auth service and an admin dashboard.

  • Game server (C#, ~1,000 lines): UDP with a 30 Hz tick loop, 12-player rooms, separate receive and tick threads, and a bit-packed protocol (24-byte player poses, 57-byte disc state).
  • Reliability layer: sequence numbers, acknowledgements, retransmits and duplicate suppression for the messages that must arrive (joins, goals, scores).
  • Token verification: the game server validates PlayFab session tickets, caches results, and uses derived-key encrypted tickets with support for key rotation.
  • Flask backend (~4,000 lines, ~70 routes): room lifecycle, Vivox voice tokens, leaderboards, purchases and admin actions, with secrets kept in environment variables.
  • Admin dashboard (WinForms, ~1,500 lines): login, player and device bans, item grants, stats and server list, in the same design language as my Orion Dashboard.
  • Ops: a PowerShell script that creates a low-power Windows power plan for the server PC and can revert it.
Unreal EngineC++C#EOSAndroidQuest

A2 — self-hosted server for a UE VR game

A self-hosted server and level editor for A2, an Unreal Engine VR game, so players can run their own games instead of depending on the official backend.

  • Server stack (.NET 6): matchmaking, player data, an EOS gateway and a dashboard, fronting a headless Windows game server driven by an operator payload DLL.
  • Cross-build joins: the Quest and PC builds speak different network versions and sit on different EOS products, so they can’t join each other — I built a version-spoof layer on the server and a native Android join mod on the client so any build can join the same game.
  • Matchmaking: worked out the EOS session-filter wire format so the server browser lists real hosted sessions instead of only official ones.
  • Level editor: a spec editor for the game’s level format, with per-build offsets pinned for each release.
  • Voice: the backend mints Vivox tokens so voice chat works on self-hosted servers too.
C#WinFormsWin32

RE Suite

A toolkit of Windows reverse-engineering utilities for studying software I own or am authorized to test.

  • Hex and memory editors using the Win32 process-memory APIs
  • String scanner and an HTTP/TCP/UDP API client
  • Network proxy and disassembler modules scaffolded as the next steps
  • Voice Changer Pro: WinForms app with DWM frosted glass and NAudio device enumeration
  • API dashboard with JWT parsing
  • One shared dark design language across every tool
PythonFlaskPlayFabPhoton

Game backend & security audit

The Python services behind my games: authentication, purchases and player data, as a ~4,000-line Flask app.

  • Audited the service and found hardcoded secrets, a bypass path and plaintext password storage
  • Fixed duplicate grants and a strike-counter race condition using a write-nonce compare-and-set
  • Switched to verified platform claims instead of raw JWTs, and added per-item purchase cooldowns
  • Designed Vivox voice-chat integration for Unity and UE5, weighing client-side token signing against server-side minting
Security researchHTTPDisclosure

Security research & responsible disclosure

Independent research into authentication and backend trust boundaries, reported through the vendor’s own channels rather than used.

  • Reported and fixed: a server-side authorization bypass in a live multiplayer game’s backend that let blocked client requests reach a privileged internal endpoint.
  • Reported and fixed: hardcoded credentials and API keys left in shipped game builds.
  • Reported, pending: an authentication-handling vulnerability in a major platform’s player-verification API, submitted through its bug bounty program.

I don’t publish exploit mechanics, patched or not — happy to discuss responsibly in an interview or with the right NDA.

Security researchAndroidKernelARM64Frida

Quest kernel research

Independent research into the Quest 3 and 3S trust chain and kernel attack surface — understanding how the device decides what to trust, and where that breaks down.

  • Root and bootloader: research into the Quest 3S boot chain, including which partitions and services run with elevated privilege.
  • Kernel triage: worked through published kernel vulnerabilities against the Quest kernels to determine which headsets and builds are actually affected, and which are already patched.
  • Attestation: studied how the device reports its own integrity, using inspection-only Frida logging that records what the attestation calls send without forging or altering anything.
  • Tooling: a reverse-engineering setup built around Ghidra, JADX and Frida for reading ARM64 binaries and instrumenting live processes on-device.

Research only — I don’t publish exploit mechanics, patched or not.

KotlinJavaC++OpenXR

AdbConsole & QuestInput

A Quest VR app in Kotlin with a companion native OpenXR app that reads Touch controller input and passes it to Java over JNI.

  • Built the OpenXR native app and JNI bridge from scratch
  • Diagnosed a silent failure caused by an OpenXR FindClass classloader issue
C#.NET 8WinFormsADB

ADB GUI Tool

One toggle that puts a headset on ADB-over-Wi-Fi: finds the USB device, switches it to TCP/IP mode, reads its Wi-Fi address and connects, with no typing. It reverts itself and explains why if anything fails.

C#Bluetooth LEWindows

QuestBleClient

A Windows Bluetooth LE client for Quest headsets with a transport layer, session manager and encryption helper, plus a device scanner that filters nearby headsets. About 800 lines of C#, with its own protocol, command-ID and device-enum layers.

C++Unreal EngineImGuiDirectX 12MinHookLua

UnrealExplorer — Unreal Engine runtime inspector

A C++ DLL that draws an in-process inspector over an Unreal Engine game, to study how its objects, classes and functions fit together. Built as a research and learning tool.

  • Batch tooling for packing and unpacking UTOC/PAK archives
  • Hooks the DirectX 12 swap chain Present and command-queue calls with MinHook, and renders a Dear ImGui overlay on top, including its own descriptor and barrier handling
  • Four tabs: an object browser, a class browser, a function-hooking list and an embedded Lua console
  • A reflection layer that walks Unreal property and class metadata, built on a generated SDK of 700+ headers
  • A C# frontend for an SDK dumper, with config generation and process detection
  • An in-game level editor with Unity-style move, rotate and scale gizmos
03 / STACK

Languages & tools

Languages

C#C++PythonKotlinJavaLua / Luau

C# for Unity and Windows tools, C++ for native and Unreal work, Kotlin and Java on Android, Python for services, Luau for scripting in a custom VR engine.

Game & VR

UnityUnreal EngineMeta QuestOpenXR

Locomotion, physics, haptics, level editors and shaders, shipped to standalone headsets.

Backend & networking

FlaskPlayFabPhoton FusionVivox

Auth, player data, purchases, regional multiplayer and voice chat.

Platform & tooling

Windows internalsADBGradleIDA ProFrida

Win32 process memory APIs, Android builds and debugging, and static analysis of ARM64 binaries.

04 / ARTIFACTS

Evidence

Nova gameplay: a robot and a glowing disc in a purple arena
The Nova robot character model and rig in Blender
Discord: Blaku explaining the room-code mapping - MasterPlayerAccountId is the SharedGroupId, KeyToFollow is the Key, RoomToJoin is the Value
Internal dev/test console: server list and tool tabs
05 / CONTACT

Let’s build something

Blake@blaku.de Blaku.de Medical Portfolio Resume