WAND Jobs Hiring Now

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 Mission

The gaming industry is undergoing a massive transition. While the market has never been bigger, players are drowning in an ever-expanding sea of content, yet abandoning games at record rates due to pacing, friction, or simply getting stuck. When they look for help, they are forced into a broken paradigm: alt-tabbing out of their game to wade through ad-heavy media sites, spoiler-filled wikis, or tedious 15-minute YouTube walkthroughs.

Wand is building the augmentation and intelligence layer to fix this. Our technology reads game state in real time, powering a unified ecosystem across desktop, web, and native game overlays. By giving players true agency—turning games into sandboxes and providing contextual help, interactive maps, and utility-driven video clipping exactly when they need it—we remove the friction between a player and their enjoyment of a game. Over 40 million gamers have already found us, largely through word of mouth, because we solve this fundamental problem.

Delivering on that mission 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 wrote very careful native code at that seam. As the surface area of what we ship grows, the team that owns the seam needs to grow with it.

Role Overview

We’re hiring a Senior Windows C++ Engineer to own meaningful parts of the native infrastructure underneath Wand. You’ll partner closely with our native tech lead and the application teams who build on top of your work. The shape of the role is part deep systems work, part platform-team mindset: the foundation has to be solid, but the win condition is what other teams ship on top of it for the millions of players using Wand today.

This is a senior individual contributor role. You’ll make architecture calls the rest of engineering will live with for years, mentor the engineers around you, and move fluidly across the breadth of the native stack as the work demands. Most of all, you’ll measure your own success by the features other teams were able to ship because the foundation made it easy.

We’ve recently shipped the plugin system that opens our native runtime to safe, in-process extensions. One thread of current work is a Lua scripting layer built on top of that plugin system. There’s plenty more going on across the rest of the stack — engine and runtime work, in-game systems, the systems that record and replay moments worth keeping — and the expectation is you can move between any of it as the work demands.

What You’ll Do

Build and own native infrastructure

• Own substantial parts of Wand’s Windows native stack and move fluidly across the breadth of it. Take pieces from design through production through the unglamorous work of keeping things stable as they scale. You’ll be responsible for the systems other teams depend on, and you’ll be the one owning the fix if and when something misbehaves.

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

Enable the rest of engineering

• Design SDK and plugin surfaces that other people actually want to build against. Clean lifecycles, sane versioning, defensive boundaries that fail predictably. The interfaces you ship will outlive the features that motivated them, and they’ll serve a widening set of consumers over time.

• Treat the application teams as your customers. When they’re shipping a feature on top of native, get in the thread with them, find the rough edges, and file them down. The fastest way to ship more features is to make the next feature cheaper than the last one.

• Write the docs, examples, and small tools that turn “ask the native team” into “look it up.” A good answer scales; a great one doesn’t need to be asked twice.

Raise the bar across the team

• Provide substantive and thoughtful code reviews. Catch race conditions, memory ordering, and lifetime bugs before they reach a player. Raise the level of the discussion when the design needs it, not just the implementation.

• Mentor mid-level engineers through the parts of Windows that aren’t on Stack Overflow. Teach the why, not just the fix.

• Contribute to roadmap decisions with an eye on outcomes. What’s the fastest way to realize value from the infrastructure we’re investing in? What’s worth refactoring, deprecating, or shipping fast and rewriting later? Bring thoughtfulness and genuine
  passion for the work.

Who You Are

Core Requirements

• 7+ years of professional C++ development, with a meaningful chunk spent on tools, engines, or platform-style systems where your users were other engineers, designers, or content authors. You can talk about what you built, who used it, and how their work changed because of it.

• Deep Windows native experience: Win32/64 APIs, DLL lifecycles, hooking, IPC, process and thread management. Comfortable in WinDbg, Process Monitor, and the Visual Studio debugger when something genuinely interesting goes wrong.

• Confident with concurrent programming. Thread-safe code is a default, not a heroic project; you spot races and ordering bugs in code review without a checklist.

• Plugin or extensibility experience. You’ve designed an interface that someone else built on top of, and you’ve lived with the result long enough to learn from it.

• Outcome-oriented and low-ego. You measure success by what the team shipped, not by what you personally wrote. You can say “I was wrong” cleanly and move on.

• Strong written and verbal communication. You can explain a hooking subtlety to someone who’s never written a line of native code, and you write design docs that people actually finish.

• Should be available to work in US timezone

Bonus Points

• Experience inside or alongside Unreal and/or Unity at depth — engine internals, gameplay code, or external native processes integrating with them. Strongly preferred; the more recent and the more hands-on, the better.

• Experience working full stack - going from Typescript in an Electron desktop app all the way down into C++ code and back will be an expectation on a number of projects.

• You’ve built or significantly contributed to a scripting or SDK layer (Lua, AngelScript, a custom DSL, a trigger system, a blueprint-style visual environment) that exposed a constrained surface of native systems to a real set of consumers — other engineers, designers, content authors, or less technical end users.

• AAA game engine, tools, or editor background.

• Familiarity with OBS internals or other video capture stacks.

• gRPC, Protocol Buffers, or FlatBuffers comfort.

• Github workflows and CI/CD familiarity.

• CMake and vcpkg fluency on a non-trivial multi-project build.

What We Offer

• 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.

How to Apply

Please submit your resume.

Join us in creating the ultimate PC gaming companion!

Wand is an equal opportunity employer committed to building a diverse and inclusive team. We welcome applications from all qualified candidates regardless of background.

Compensation Range: $150K - $250K