Learn To Make CHEATS for any GAME in 18 Minutes transcript

Did you know that it costs absolutely zero money to make your own cheats for the games you play? Cheat developers create these projects completely for free and then turn around and sell them to you for hundreds of dollars every single month. In this video, I'm going to show you exactly how to break that cycle and build your own cheat for literally any game. We're going to build a menu from scratch that looks and feels just like a premium paid software complete with a clean ESP hack, a fully functional aimbot and a responsive cheat menu.

By the end of this video, you will be able to create this exact same cheat that you can see right now on For this guide, I'll be using Counter-Strike 2 as our target game to teach you the fundamentals. The core logic we are covering remains the exact same for every single game on the market, but I heavily recommend starting with CS2 to learn. You can't realistically learn game hacking by diving straight into a massive game protected by aggressive kernel level anti-cheats like Valorant or Fortnite.

You need to learn the core concepts first on a game with a less intrusive anti-cheat like CS2. Once you master how the memory logic works here, you'll have the foundation needed to adapt it to any game you want. First, we need to understand how cheats actually work. don't understand the core concept, you won't be able to build a cheat for your favorite game. Every single cheat you've ever seen, whether it's for Fortnite, Valorant, or any other game, is just an app.

It's exactly like Steam, Discord, your web browser, or even the game itself. When we make a hack, we are simply building our own app that hacks the game. To build an app, you use a programming language like Python or C++. But don't worry, I'm not going to tell you to go out and learn an entire programming language today. I've made this tutorial so simple that anyone can follow along and build their first cheat. If you don't know what a programming language is, think of it as the language of computer.

Your PC is like a personal assistant that follows your instructions exactly. When we make an app, we just give that assistant a list of instructions. To make a cheat, we use that language to tell the computer exactly how to hack the game. Sounds easy, right? Now, let's get straight into the tutorial. The first thing you need to do is install Visual Studio. This is the software you need to use to create any app for Windows and it's exactly what we'll be using to create our cheat as well.

To download it, click the link in the description. Run the installer and make sure to check desktop development with C++ while installing it. Next, grab the source code file from the link in the description. Extract the archive, open Visual Studio, and hit open a project or solution. Just navigate to where you extracted everything and open the .sln file to load up the project. When you open it for the first time, it might look completely empty.

Just head over to the right side, look at the solution explorer, and open up the branchlink.cpp file. Now, when you look at this file, you'll see a lot of random words. This is written in C++, the programming language used for building all sorts of software and the most common language for developing both games and cheats. Like we talked about earlier, these words are just the exact instructions I've written to tell our cheat app how to work.

And don't worry, you don't need to guess what any of it means. I am going to break it down and tell you exactly what each line does in a very simple, easy-to-understand way. Next, you need to make sure your game is running in windowed full screen or borderless windowed mode. If the game is running in full screen mode, our cheat won't be able to draw an overlay on top of it. So, go into your game settings right now and switch it over.

Now, let's understand the exact instructions we need to give our app to actually turn it into a cheat. First, we need to tell it to draw a new, completely transparent window right on top of the game so we can spawn our menu, ESP boxes, lines, and player skeleton. To make this easy, cheat developers use a popular tool called Dear ImGui. I've already set it up for you in this project, so you don't have to waste time doing it manually.

Did you know that every game you play, whether it's CS2, Fortnite, or PUBG, always knows exactly where every player on the map is and what their health is, even when they're hidden behind walls? Cheat developers abuse this exact design flaw. We just need to tell our app to pull this information out of the game and use ImGui to draw boxes and lines over the players using that data. To extract this from the game, you need to use something called offsets.

Offsets are just numbers, but they are written in a hexadecimal format instead of the typical decimals we use every day. Hexadecimal is just a different way for computers to read numbers. For example, the number 15 is written as 0x F, and the number 255 is written as 0xFF. These offsets are different for every single game, and they change every single time a game updates. If a new update drops, you have to find the new offsets, or the cheat won't work.

You need offsets for absolutely everything you want to show, like player positions, player health, the location of important items, and everything else. Now, scroll down until you find int main. This is the official starting point of our cheat program, meaning whatever instructions we put here will be executed first. Inside you will see a line that says mem.attach with cs2.exe written next to it. This tells our cheat app to attach itself to Counter-Strike 2.

We have to attach to the game's process before we can pull any of that information or use those offsets we talked about earlier. If you want to hack a different game in the future, this is the exact line where you will change the name to match that game's process. Right below that, you will see mem.getmoduleaddress. This gets the base address of a specific game module. For example, in CS2, a file called client.dll holds all the critical data, like enemy positions and health.

So, we target that module here to gain access to everything inside. Just like the process name, when you move on to hack other games, you'll need to find and swap in their specific module base addresses right here. You might be wondering how we actually find these offsets. There are two main ways to do it. The difficult way is to reverse engineer the game yourself. Reverse engineering means pulling the game apart to figure out exactly how the developers built it from the inside out.

Since that's a bit too complex for beginners, we're going to use the easier method, a dumper. A dumper is an automated tool that scans the game while it's running and extracts all the offsets for you automatically. There are dumpers available for almost every game out there. You just have to look for them. For this video, we're going to use the CS2 dumper by a2x, and I've linked it in the description. To use the dumper, make sure your game is open and running in the background, then just launch the dumper like a normal program.

Once it finishes scanning, it will generate a new folder called output. Go inside that folder, and you'll find two specific files we need, offsets.hpp and client_dll.hpp. If you open these files up, you'll see a massive list of all the updated offsets for everything in the game. All you need to do is copy everything inside these files, go back over to Visual Studio, and paste them right into the matching offsets.hpp and client_dll.hpp files in your project to fully update your cheat.

Once that's done, look at the top of Visual Studio. Hit that green play button, and if you followed every step correctly, your cheat menu will pop up instantly without a single error. As you can see, the ESP is fully working. We have clean boxes, health bars, and full skeleton ESP drawing right over the players. You can press the insert key anytime you want to hide or show the menu, and if you need to shut it down completely, just hit the end key to stop the cheat.

But, wait, there are a few problems we need to address right now. First, it might look like I just told you to download a pre-made cheat and hit run. That is definitely not what's happening here. I pre-configured the source code to save us time. I didn't want to drag you through a boring 1-hour tutorial of me typing out every semicolon. The goal of this channel is to teach you as fast as possible without wasting your time.

I'm not ending the video here. We're going to dive straight into the code right now, so you can understand exactly how it works and actually learn the logic. The second problem is that the menu is currently non-functional. All the features you see on the screen, the boxes, the health, the skeletons, are active right now, but toggling the buttons in the menu doesn't actually turn them on or off yet. I intentionally left it this way, so I can show you how to wire them up yourself.

By the time we finish this video, you will fully understand how cheat logic connects to a menu and how you can apply this to any game you want. Let's start by customizing the menu itself. Inside that same int main function, scroll down until you find the word begin suggests, this is where our menu UI actually starts. We are basically telling ImGui to create a new window for us. The text inside the quotation marks here is what appears as the title at the top of our menu screen.

If you want to personalize this and give it your own name or your community's name, just change the text inside these quotes. As soon as you edit it and hit run again, you can see the title changes instantly. The code right below that handles the sidebar tabs you see on the left side of the menu. You can see all the existing tabs listed out right here. If you want to add a brand new tab, just add a new line to this list following the exact same format.

You can also delete any tabs you don't want. The only thing you need to remember is to update the the right above it. Change that I less than four count to match whatever your new total number of tabs is, or the menu won't render them all correctly. And just like that, we have a new tab. As you can see, the new tab we just created is completely empty. Let's fill it up. To do that, scroll down until you see the code for ImGui I colon colon begin child main content.

This is the section responsible for displaying the actual buttons and settings for whichever tab you click on. If you look closely at the logic, you'll see it starts with if active tab equals zero, which holds all the features for very first tab, the aimbot. Below that, else if active tab equals one handles the second tab, which is the ESP. Following this exact same pattern, we can add contents for our new tab. Since this is our fifth tab, we're going to write else if active tab equals four.

We use the number four because in programming, counting always starts from zero, not one. So, tab one is zero, tab two is one, and our fifth tab is four. Let's start by adding some text to our new tab. To save time, I'll just copy the text layout code from the previous tab. First, look at the set window font scale line. This exactly controls the size of the text. You can increase or decrease this number to change the scale.

For a main heading, you'll want to use a larger font size. Just make sure that right after your heading, you add another scale line to lower it back down so that all the regular text and options you create below it stay at a normal, smaller size. To actually display the words on the screen, you use the instruction ImGui UI double colon text. Inside the parentheses and quotes, you can type absolutely anything you want, and ImGui will draw it onto your menu instantly.

Now, you want to give your users some actual options to toggle the features of your cheat on or off. To do that, we use a UI element called a checkbox. Before we add the visual checkbox to the menu, we need to create a place in memory to store its state. To do that, we're going to create a bool variable. A variable is just a container that holds data for us, so we can use it later. In this case, a bool is short for boolean, meaning it can only hold two values, true or false.

We will use this variable to track whether our cheat feature is turned on or off. If this sounds a little complicated right now, don't worry. Just follow these next few steps and you'll see exactly how it connects. To create a bool variable, type out the code exactly as you see here. You can choose any name you want for this container. In this example, I've named it option, but feel free to call it whatever makes sense to you.

Now, let's link it to the menu. To create the actual visual checkbox, type ImGui double colon checkbox. Inside the quotation marks, type the text you want to appear next to the box in your menu. Right after that text, we need to pass in our bool variable with an ampersand, exactly like I've done here. This tells the menu to automatically change our variable to true when the box is checked and false when it's unchecked.

Another common feature is a slider, which is perfect for adjusting values like aimbot speed or FOV radius. To make one, use the ImGui double colon slider float function. We need a float variable to store the value, which just means a number with decimal points like 0.1 or 5.5. When you call the function, pass in the text label, your float variable, and then specify the minimum and maximum values to set the exact boundaries for the slider.

Let's run it, and as you can see that we have a slider. Now, scroll up until you find the void hack game function. As the name suggests, this is the actual core code responsible for everything we discussed earlier. In short, this function uses your offsets to pull live data straight out of the game's memory and then tells ImGui exactly where to draw the ESP lines, boxes, and player skeletons on your screen. The very first thing this function does is get the entity list and the view matrix.

The entity list is a specific section of the game's memory that contains the live data for every single player on the map. We need to target this list so our app can pull the locations and health of our enemies. But, there's a catch. Your computer monitor is a flat 2D screen. When you play a 3D game, the engine uses clever math to create the illusion of depth on that flat surface, just like drawing a 3D cube on a flat piece of paper.

Because the player coordinates we pull from the game are in 3D space, we have to convert them back into flat 2D screen coordinates, so our ESP knows exactly where to draw. To do that conversion, we use the game's view matrix. Next, the function gets the local player. Local player simply means you, the person playing the game, not your enemies or your teammates. We need to grab our own player data so we can find our specific team ID.

We use this team ID to filter out teammates so our cheat only targets the enemies. If we skip this step, the app won't know the difference and will draw ESP boxes or lock aimbots onto your own team. Scroll a bit further down and you will see the lines where the app reads the health and team ID of each player it finds. Right below that, you can see the exact conditional logic that compares the player's team ID against our own local player team ID.

If they match, the code skips them entirely, ensuring the cheat stays focused strictly on the enemy team. Next, we need one last piece of data before we can actually draw our ESP, and it's the most important thing of all, the exact position of the players. To get this, we access something called the bone array. The bone array is a specific part of the game's memory that holds the live 3D coordinates for every single bone in a character's body.

We need this data to pinpoint exactly where our enemies are standing so we can track them through walls and draw an accurate skeleton ESP over them. In fact, the entire ESP and the aimbot completely rely on these positions. You literally cannot make a cheat if you don't know where the enemies are. That's the whole point of an ESP, and this code does just that for us. Once we have that bone array data, we hit the final step before drawing.

Like we discussed earlier, these bone positions are stored by the game in 3D space. So, we pass them right into our world to screen function, which handles the math to convert those 3D coordinates into flat 2D positions on your monitor so our ESP hack can draw the lines perfectly in place. Next up is our aimbot logic. For a good aimbot, you don't want your crosshair randomly snapping to players all the way across the map.

You want it to target the enemy within your FOV radius and closest to your actual crosshair. This section of the code handles that math for us, constantly checking the distances and finding the perfect target. The remaining blocks of code below this are simply responsible for the actual drawing. We use the overlay double colon's box and line functions to instantly render the bounding boxes, lines, and health bar ESP directly onto your screen based on all that data we collected.

Now, if you want to change the color of your ESP features, it's incredibly easy. Just search for an RGB color picker on Google, dial in whatever custom color you want, and copy the RGB values it gives you. Then come back to the code and look for IM_COL32. Inside the parentheses, you can just paste your new RGB values right over the old ones. The fourth and final number in that function represents the transparency. You can tweak it if you want your ESP to look a bit more see-through, but I'm going to leave it exactly as it is for now.

And as you can see, we have changed our box ESP color to red. Now, let's look at how the aimbot actually works. Since we already know the exact location of the enemies, we simply need to tell our mouse to move until the enemy is locked directly onto our crosshair. And since the crosshair in almost every game is always perfectly at the center of the screen, the math becomes straightforward. While the previous code we looked at was strictly responsible for finding the absolute best target nearest to our crosshair, this block of code right here takes that target's position and actually moves our mouse until the enemy is perfectly centered on the screen.

Now, let's actually make our menu functional so our cheat features only turn on or off when we toggle them on the screen. Go back to our main function where the tab code lives. As you can see, we created a checkbox linked to a bool variable called enable_aim, that is for our aimbot toggle. Below it, we have our sliders for the aim smoothing and the FOV radius, plus a combo box for selecting exactly which bone of the enemy we want to target.

Right now, these variables are trapped inside our main function. To use them inside our hacking logic, highlight these variables, press control X to cut them, and then scroll all the way to the top and paste them right before our hack game function. This turns them into global variables, meaning they can now be read and used anywhere in our entire project, including inside our hacking loop. Next, let's head right back into our aimbot code that we just discussed.

Now that our variables are global, we can finally utilize them here. First, we're going to take enable_aim and wrap our entire aimbot logic inside an if statement checking for this variable. As you can see, by doing this, our aimbot will remain completely idle and won't execute a single line of code until we actually toggle it on using the checkbox in our menu. All right, let's hook up the sliders and the body part selection for the aimbot.

To do that, we just need to swap out the hard-coded numbers in our code. Find where the aimbot FOV radius is set and simply replace that static value with our sliders variable. We do the exact same thing for the aim smoothing value, as well. Now, whenever you slide those bars on your menu, the cheat will instantly update in real-time. Next, for the aimbot bone selection, we can use simple if conditions to check exactly what the user picked in the combo box.

If the selected bone variable equals zero, it means the head is selected, so we assign the head bone's ID to our target variable. If it equals one, the neck is selected. And if it equals two, then that means the body or pelvis is selected. Remember, as I told you earlier, counting the order of elements in programming always starts with zero, which is why our options go from zero to two. I am also going to remove the chest option from the combo and replace the pelvis option to body, so it's easier for the users to understand.

Now, let's check how everything is working. As you can see, everything is working perfectly. Now, let's fix the very last thing, which is our ESP options. The first thing I'm going to do is rename our name ESP option to skeleton ESP instead, because we don't actually have a name ESP in this build. When you change a name like this, you also need to make sure to rename its variable everywhere it is used in the project, or your compiler will throw errors.

While we are at it, let's create a brand new bool variable in that same global area, which we'll use for toggling our health ESP on or off. Watch closely as I rename the variable across the code to clear out these red error lines, and then we will quickly create a brand checkbox in the menu for the health ESP. Next, we just need to link these new variables to the drawing logic inside our hack game function. Scroll to the code for the skeleton ESP.

I'll simply wrap this in an if statement, just like we did with the aimbot, to check if our skeleton ESP variable is true. We'll place our overlay double colon's line functions right inside it. Our skeleton hack also draws a red circle for the enemy's head, so we need to make sure that circle is wrapped inside this exact same if statement. So, it only draws when the user wants the skeleton visible. Finally, I'll do the exact same thing for the bounding box and the health bar ESP code, wrapping them in their own toggle.

And now, when we hit run, you can see absolutely everything working smoothly and responding to the menu dynamically in real time. And that is how you make your very first cheat. Now, your next step is to take everything I've taught you today and start experimenting. Try changing things around, tweak the colors, adjust the sliders, or try adding a brand new tab to the menu by playing with the code. Breaking things and figuring out how to fix them is exactly how you truly learn.

And remember, if you want to hack any of your favorite games in the future, the core rules remain exactly the same. No matter the game, your workflow is always going to be find the entity list, grab the view matrix, locate the player position offsets, pass them through a world to screen function, and then use your overlay to draw the lines and boxes on top of them. This foundational logic never changes.