Apprentice Software Reverse Engineer Jobs in New York

Wand makes gaming magical. Through game customization and guidance, we build tools that helps players have more fun in their favorite games.

Our platform works across thousands of PC games, ensuring that great games are accessible to everyone, regardless of time constraints, skill level, or accessibility needs. We want to build the future of game assistance, and we're hoping you'll join us.

The gaming industry is undergoing a massive transition. The market has never been bigger, but players are drowning in content and abandoning games at record rates. Wand is building the fix: a per-game companion OS that runs alongside whatever you're playing and gives you real agency over it. We read game state in real time and power a unified experience across desktop, web, and native in-game overlays, organized around the three things a player wants to have more control over the game in front of them — mods that turn a game into a sandbox, maps that tell you where to go, and a growing shelf of tools to get unstuck, plan, capture, and create. Over 40 million players have already found us, largely through word of mouth.

Delivering on that depends on a small group of engineers working at one of the trickier seams in software: the boundary between Windows, third-party game engines, and our own product. Everything Wand does for a player while their game is running happens because someone reverse-engineered that seam and wrote very careful native code to hold it together. As the surface area of what we ship grows — and as LLMs make mods and tools faster to build — the team that owns that seam needs to grow with it.

We're hiring a Senior C++ Reverse Engineer to own the deepest layer of Wand's native stack: the game engine SDKs that lets us understand and safely operate inside a running game. It's the foundation every mod and in-game tool is built on.

The centerpiece of that work is our integration with game engines through an SDK and scripting layer. You'd be working on that centerpiece and owning the infrastructure along with the hooking, scripting, and cross-DLL machinery layered on top.

This is a senior individual contributor role, and it sits at the deep-systems, engine-internals end of our native team. You'll partner closely with our native tech lead and CTO, make architecture level decisions, and move across the breadth of the native stack as the work demands. Most of all, you'll measure your success by what other teams were able to ship on top of the foundation you keep solid — the millions of players modding their games today never see this layer, and that's exactly the point.

Own the engine-integration framework

• Own our game engine SDKs — Unreal and Unity specifically. You’ll be working on the interface between our mod engineers and the underlying game engine. This entails owning keeping that system working as engines change version to version, extending it to new capabilities, and being the person who diagnoses it when a game update or a new engine release breaks something underneath.

• Go deep when the framework meets the metal. When the SDK needs to find something new in an engine, or a title behaves in a way nothing else explains, you're comfortable dropping down to the disassembly, working out what the engine is really doing, and turning that into something the framework can rely on. You maintain the machinery that lets mod engineers ship — you're not shipping the individual mods yourself.

• Own the hooking and cross-DLL machinery. Vtable, pointer-slot, and inline hooks across the object lifecycle, and the system that lets multiple mods operate inside one game process without stepping on each other.

• Make the architectural decisions that compound. Balance accuracy against latency, safety against performance, surface area against maintainability — and communicate the reasoning so the rest of the team can hold the line later.

Enable the rest of engineering

• Design SDK, scripting, and reflection surfaces other people actually want to build against. Clean lifecycles, sane versioning, defensive boundaries that fail predictably. What you ship here is consumed by the engineers building mods and tools on top of it — a set that only widens as that work gets easier to build with LLMs.

• Treat the teams building on the engine layer as your customers. We have internal mod engineers that are using the SDK and you’ll be interacting with them directly to address issues and improve the product. This is an internal team today but this will likely expand to a broader audience as we grow as a platform and you’ll be helping us manage that growth.

• Write the docs, examples, and small tools that make the tool chain and SDK self-service. This is even more important given that LLMs might increasingly be the author of these mods and tools.

Raise the bar across the team

• Provide substantive, thoughtful code reviews. Catch the race condition, the lifetime bug, and the brittle assumption that'll silently break the next time a game or engine updates — before it reaches a player.

• Mentor the engineers around you through the parts of Windows and engine internals that aren't on Stack Overflow or answered by Claude. Teach the why, not just the fix.

• Contribute to roadmap decisions with an eye on outcomes. What's worth refactoring, deprecating, or shipping fast and rewriting later? What end user outcomes does our reverse engineering work enable? Bring thoughtfulness and genuine passion for the work.
  

Core Requirements

• 7+ years of professional C++, with a meaningful chunk spent working deep inside software you didn't have the source to — game engines, anti-cheat, drivers, or other systems where understanding someone else's binary was the job. You can talk about what you figured out, how, and what you built on top of it.

• Reading a binary is a core skill, not an occasional adventure. You're genuinely fluent in disassembly, recognizing compiler-generated code, and finding structure in optimized builds without source or symbols.

• Deep Windows native experience: Win32/64, DLL lifecycles, function hooking (vtable, pointer-slot, inline/detour), IPC, and process/thread management. You're at home in WinDbg, x64dbg or the Visual Studio debugger, and a disassembler (IDA / Ghidra / Binary Ninja) when something genuinely interesting goes wrong.

• Confident with concurrent programming. Thread-safe code is the default.

• Game engine internals experience — Unreal, Unity, or both preferred. You've worked inside or against a large engine's runtime (reflection and object systems, memory layouts, a scripting VM or bytecode, or the equivalent) and you understand how much of it shifts from version to version.

• Outcome-oriented and low-ego. You measure success by what the team shipped on top of your work, not by what you personally wrote. You can say "I was wrong" and move on.

• Strong written and verbal communication. You can explain a subtle hooking bug or a low-level finding to someone who's never written native code, and you write design docs people actually finish.
  

• A non-traditional path into this work — security research, vulnerability analysis, CTFs, or time spent taking things apart for the fun of it.

• You've built tooling that reconstructs a program's types or structure from the outside — an SDK generator, a runtime reflection system, or similar.

• You've embedded a scripting engine (Lua/LuaJIT, AngelScript, a custom VM) and exposed a constrained, safe surface of native systems to other authors.

• Code generation or compiler tooling — emitting compilable code from metadata, or writing a compiler / protoc plugin.

• Comfortable working full stack — TypeScript in an Electron desktop app all the way down into C++ and back is an expectation on a number of projects.

• IPC and wire-protocol design: FlatBuffers, Protocol Buffers, gRPC, named-pipe framing, streaming.

• Rust, and FFI / interop between it and C++.

• CMake and vcpkg fluency on a non-trivial multi-project build; GitHub Actions CI.

• Unicode / encoding-correct native code — you don't assume ASCII (non-ASCII Windows user profiles are a first-class case, not an afterthought).
  

• Competitive compensation and equity package.

• Fully remote work arrangement.

• The chance to do unusually deep native work for an audience of 40M+ players who will actually feel the difference.

• A team of people who genuinely love games, move incredibly fast, and care deeply about what they build..

Compensation Range: $150K - $250K