2019-2021Archived

fly-high-menu

C++17 · BigBase · MinHook · DX11 · C# WinForms

Overview

Four C++ mod menus for GTA Online, iterated until FlyHigh. The features were the work.

Four C++ mod menus for GTA Online: DLLs injected into GTA5.exe, drawing an in-game menu over player, network, weapon, vehicle and recovery features. FlyHigh was the final product of the first one. The bases were open source (BigBase, and SudoMod in the Saphir generation); everything the menus could do was handwritten: protections that defuse Rockstar network events one byte at a time, a recovery suite that zeroes the casino's anti-abuse counters, spawners, teleports, and a UI drawn through the game's own native draw calls.

It started in 2019, at fifteen: GTA Online was the game, shark cards cost real money, and the menu that prints its own money does not. Money came first, the complete feature list came after, and by 2021 there was a final build, real authentication, and a private Discord community of around ten users running on it. The project retired when the interest in GTA did.

Why does a 15-year-old build a mod menu?

Because GTA was the game and shark cards cost real money. The first features were money: manipulate the wallet, spawn moneybags on the floor, rig the casino. When a Rockstar patch retired those methods, the final build disabled them in the menu itself rather than ship dead options; the rest of the menu kept growing. The goal was a complete mod menu, and a complete one has player tools, network tools, vehicles, teleports and recovery. Four C++ projects later, it was.

How much was base, how much was mine?

The menu shell came from the community's open tutorial; everything past the shell is the work. All four generations are mine, Saphir on its SudoMod base and the three BigBase menus (juice.code, Cozy, FlyHigh): the feature pipeline, the crash protections, the recovery suite, the injector, the texture pipeline, the auth integration. The bases stayed open source and credited as such; the engineering on top was handwritten from day one.

How does a mod menu work?

A DLL gets injected into GTA5.exe and hooks two clocks. The first tick rides the game's script engine: a hooked native runs the menu's scripts inside the game's own fiber. The second rides the render loop: a hooked DX11 Present draws the UI frame by frame. Every game address (game state, frame count, the native registration table) is found at runtime by signature scanning, and native calls resolve through a 6,178-line crossmap, so a game update moves the pointers without moving the menu.

Features are one tick of atomic flags: a menu option flips a bool, the tick applies it through natives. Protections work a level lower: the build carries a table of 60-plus Rockstar network events, and the dangerous ones get defused by patching their handler's first byte to RET. The menu itself draws with the game's own rect and text calls, the same native look every serious menu wore; the vendored ImGui powers a log console.

What did rigging the casino take?

Sleepless nights, then it worked. Rockstar's casino watches its own anti-abuse stats: chips won per game day, chip purchase timers, Lucky Wheel usage. The rig zeroes those counters (casinoRig() sits in Recovery.cpp next to the wheel-spin and chip-cooldown resets), and with the counters flat it could keep running. When it finally landed, the bank balance read 17 billion and everything buyable had been bought. The mechanism is in the source; the 17 billion is memory, and stated as memory.

How do you ship authentication at 15?

By using what worked. The generations each carried a scheme: one ran a self-hosted PHP server whose version check could retire old builds; one carried a multi-server setup; the final build settled on Auth.GG, a licensing service, wired in with a 453-line C++ client. The shipped build required a real login, HWID-bound over HTTPS, and it served the private community for the life of the project. Writing an auth stack from scratch came later; the fail-closed licensing backend camelbot-cs2 ships is where that lesson landed.

What carried forward from four mod menus?

The systems work in this hangar starts here. Hooks, signature scanning, native invocation, game memory, DX11, a licensing flow that held up under real users. Four C++ projects touch all of it, handwritten end to end between 2019 and 2021: checkable proof of systems code written before AI wrote code. Reverse engineering ran forward too, through the kernel work and the pattern scanning in memschema on the research shelf. When the interest in GTA ran out in late 2021, the menu ended. The skills didn't: the research shelf is where they went.

Field notes

  • ~185,000 lines of C++/C# across the four generations plus the C# injector; about a third is generated native-call tables.
  • Two clocks drive the menu: a game tick from a hooked native inside the game's script fiber, a render tick from a hooked DX11 Present.
  • Signature scanning resolves every game address at runtime; native calls cross game builds through a 6,178-line crossmap.
  • A table of 60-plus Rockstar network events, each defusable by patching its handler's first byte to RET.
  • The casino rig zeroes the daily anti-abuse stats: chips won per game day, purchase timers, Lucky Wheel usage.
  • The Saphir generation defines 9,158 menu options as call sites in a 27,538-line file; FlyHigh's entire menu definition is one 1,565-line file.
  • Menu textures load at runtime from Discord CDN links; the animated headers cycle 60 frames.
  • Last author activity in the archive: October 27, 2021.

Private and archived since 2021. The bases were open source; the features were handwritten. Listed as what it is.