each sleeve is a real project. flip it for the back side.
resurrecting a dead tank mmo server, one reverse-engineered packet at a time
A ground-up Go reimplementation of the BigWorld server stack for a retired Tanks Blitz client — no leaked server code, just the client binary, IDA with debug symbols, and a lot of packet archaeology. The Mercury UDP protocol was reverse-engineered straight from the exe (endianness quirks, remapped message IDs, RSA-OAEP login crypto, Blowfish channel encryption, entity property streams, even a hand-rolled Python pickle-2 encoder in Go). An unmodified client logs in, reaches the hangar, and plays real multiplayer battles with server-side physics, matchmaking, tank collision, shot damage, and an A* driving bot. The workspace is a whole ecosystem: an injected C++ DLL exposing live game hooks as an MCP server for AI-assisted debugging, a version.dll shim for client tweaks, a UDP MITM proxy, .sc2 map/nav parsers, a DVPL asset tool, and an RBAC admin API with a React panel.
pressed with Go · C++ (32-bit, MinHook) · Python · TypeScript · React 19 · PostgreSQL · IDA Pro · Wine
flip the sleeve ↻
- Reimplemented BigWorld's Mercury UDP protocol in Go purely from binary reverse engineering: RSA-OAEP login handshake, Blowfish channel crypto, session-key exchange, and entity-method wire codegen from .def schemas
- Built a custom game-introspection MCP server: an injected 32-bit C++ DLL (MinHook + naked-asm detour stubs) serving JSON-RPC inside the Wine game process, so an AI session can hook live functions and read memory in a single tool call
- End-to-end gameplay against an unmodified retail client: login through hangar into multiplayer battles with server-side physics, a matchmaker, tank-vs-tank collision, shot damage, and an A* driving bot on baked navgrids
- Full asset/codegen pipeline: hand-rolled Python pickle protocol-2 encoder in Go, a 349-vehicle catalog parsed from client data, .sc2 scene parsers exporting heightmaps and collision, and a DVPL codec tool
ascension-cheat
2 gh starsa c++20 dll that lives inside tanks blitz — hooks, luajit, imgui, and its own netcode
a full game-client mod for tanks blitz (windows x64): a c++20 dll that injects into the process and does its thing through inline hooks and pattern-scanned signatures, so it doesn't die every patch. features are scriptable at runtime via an embedded luajit engine with a hand-exposed api, and everything's driven from a dear imgui overlay. the spicy part is a custom udp/tcp relay (protocol v2) that syncs entity snapshots between clients with delta compression, packet fragmentation, and half-float bbox quantization — plus an atgm missile-guidance state machine whose pure math is pinned down by a separate go test suite. prod builds ship with string encryption, anti-debug/anti-dump, self-integrity checks and import obfuscation.
pressed with C++20 · LuaJIT · Dear ImGui · Go · Python · MinHook · Detours · Bullet Physics · CMake · mingw-w64 · Nix
flip the sleeve ↻
- injected c++20 dll with pattern-scan signature resolution instead of hardcoded offsets, so it survives game updates
- embedded luajit scripting engine + exposed api with hot-loaded modules from disk, driven by a dear imgui overlay
- hand-rolled udp/tcp relay netcode (protocol v2): delta compression, packet fragmentation, and half-float bbox quantization to sync entity snapshots across clients
- atgm missile-guidance state machine with pure math validated by a standalone go test suite (vec3, guidance phases, lost-target prediction)
- tiered prod build with string encryption, anti-debug/anti-dump, self-integrity checks and import obfuscation
ascension-mir-tankov
ask the selleran imgui overlay living inside a bigworld tank client, with a go relay whispering between players
reverse engineering playground built around «Мир танков» (Lesta's BigWorld-engine client). a DLL gets injected into Tanki.exe, hooks IDXGISwapChain::Present via MinHook and draws an ImGui overlay right over the game, while a hot-reload framework runs user scripts inside the game's embedded Python 2.7. fun constraint: Lesta strips _ctypes from their build, so the native overlay and the Python side can't FFI — they talk purely over HTTP. on the side, a Go relay server pairs clients by arena and team and shuttles encrypted entity snapshots over UDP/TCP.
pressed with C++ · Go · Python 2.7 · ImGui · MinHook · DirectX/DXGI · Nix · Docker · Wine
flip the sleeve ↻
- Hooks IDXGISwapChain::Present via MinHook to render an ImGui overlay directly over the game's frames from an injected DLL
- Hot-reload mod host running inside the game's embedded Python 2.7 — each user script executes in its own namespace, with a ring-buffer logger, REST/HTTP servers and a webgui
- Worked around Lesta stripping _ctypes from the client: the native overlay talks to the Python side purely over HTTP instead of in-process FFI
- Reproducible Nix flake build that cross-compiles the Windows x86_64 DLL with MinGW and injects it via Wine; Go relay ships with encryption, TTL sessions and both UDP and TCP transports
ascension-relay
0₽ + shippingthe game mod grew its own backend
companion server for ascension-cheat, written in Go. clients on the same team push UDP position snapshots and the relay fans them out to everyone else in the same arena — custom binary protocol with a "RELY" magic, XOR-obfuscated payloads, sessions cleaned up by TTL. a TCP side handles chunked vehicle-mesh sync with per-team leader election, including takeover when a leader goes quiet. all state lives in memory, config comes from env vars, and the README honestly admits XOR is obfuscation, not encryption.
pressed with Go · UDP/TCP netcode · slog · Shell
flip the sleeve ↻
- Custom versioned binary protocol (magic 0x52454C59 "RELY") with XOR-obfuscated payloads and snapshot/ping/pong message types
- UDP snapshot fan-out keyed by (arena, team) with TTL-based session expiry — teammate state sharing over a dumb-fast relay
- TCP mesh store for chunked vehicle-geometry uploads: per-team leader election with timeout-based takeover, completeness tracking per part
- Zero external deps beyond stdlib: RWMutex in-memory stores, env-var config, structured logging via slog, plus unit tests on the mesh store