YT YouTube2Text

YouTube2Text → Transcripts → Learn To Make CHEATS for any GAME in 18 Minutes

Learn To Make CHEATS for any GAME in 18 Minutes — Transcript

by BranchLink · 4,266 words · 606 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00Did you know that it costs absolutely
0:01zero money to make your own cheats for
0:03the games you play? Cheat developers
0:05create these projects completely for
0:06free and then turn around and sell them
0:08to you for hundreds of dollars every
0:10single month. In this video, I'm going
0:12to show you exactly how to break that
0:13cycle and build your own cheat for
0:15literally any game. We're going to build
0:16a menu from scratch that looks and feels
0:19just like a premium paid software
0:20complete with a clean ESP hack, a fully
0:23functional aimbot and a responsive cheat
0:25menu. By the end of this video, you will
0:26be able to create this exact same cheat
0:28that you can see right now on For this
0:30guide, I'll be using Counter-Strike 2 as
0:32our target game to teach you the
0:33fundamentals. The core logic we are
0:35covering remains the exact same for
0:37every single game on the market, but I
0:38heavily recommend starting with CS2 to
0:40learn. You can't realistically learn
0:42game hacking by diving straight into a
0:43massive game protected by aggressive
0:45kernel level anti-cheats like Valorant
0:47or Fortnite. You need to learn the core
0:49concepts first on a game with a less
0:50intrusive anti-cheat like CS2. Once you
0:53master how the memory logic works here,
0:54you'll have the foundation needed to
0:56adapt it to any game you want. First, we
0:57need to understand how cheats actually
0:59work. don't understand the core concept,
1:01you won't be able to build a cheat for
1:02your favorite game. Every single cheat
1:04you've ever seen, whether it's for
1:05Fortnite, Valorant, or any other game,
1:07is just an app. It's exactly like Steam,
1:09Discord, your web browser, or even the
1:11game itself. When we make a hack, we are
1:13simply building our own app that hacks
1:15the game. To build an app, you use a
1:16programming language like Python or C++.
1:19But don't worry, I'm not going to tell
1:20you to go out and learn an entire
1:21programming language today. I've made
1:23this tutorial so simple that anyone can
1:25follow along and build their first
1:26cheat. If you don't know what a
1:27programming language is, think of it as
1:29the language of computer. Your PC is
1:30like a personal assistant that follows
1:32your instructions exactly. When we make
1:33an app, we just give that assistant a
1:35list of instructions. To make a cheat,
1:36we use that language to tell the
1:37computer exactly how to hack the game.
1:39Sounds easy, right? Now, let's get
1:40straight into the tutorial. The first
1:42thing you need to do is install Visual
1:43Studio. This is the software you need to
1:45use to create any app for Windows and
1:47it's exactly what we'll be using to
1:48create our cheat as well. To download
1:50it, click the link in the description.
1:51Run the installer and make sure to check
1:52desktop development with C++ while
1:54installing it. Next, grab the source
1:56code file from the link in the
1:57description. Extract the archive, open
1:59Visual Studio, and hit open a project or
2:01solution. Just navigate to where you
2:03extracted everything and open the .sln
2:05file to load up the project. When you
2:07open it for the first time, it might
2:09look completely empty. Just head over to
2:10the right side, look at the solution
2:12explorer, and open up the branchlink.cpp
2:14file. Now, when you look at this file,
2:16you'll see a lot of random words. This
2:18is written in C++, the programming
2:20language used for building all sorts of
2:21software and the most common language
2:23for developing both games and cheats.
2:25Like we talked about earlier, these
2:26words are just the exact instructions
2:28I've written to tell our cheat app how
2:29to work. And don't worry, you don't need
2:31to guess what any of it means. I am
2:32going to break it down and tell you
2:33exactly what each line does in a very
2:35simple, easy-to-understand way. Next,
2:37you need to make sure your game is
2:38running in windowed full screen or
2:40borderless windowed mode. If the game is
2:41running in full screen mode, our cheat
2:43won't be able to draw an overlay on top
2:44of it. So, go into your game settings
2:46right now and switch it over. Now, let's
2:48understand the exact instructions we
2:49need to give our app to actually turn it
2:51into a cheat. First, we need to tell it
2:52to draw a new, completely transparent
2:54window right on top of the game so we
2:55can spawn our menu, ESP boxes, lines,
2:58and player skeleton. To make this easy,
3:00cheat developers use a popular tool
3:01called Dear ImGui. I've already set it
3:04up for you in this project, so you don't
3:05have to waste time doing it manually.
3:07Did you know that every game you play,
3:08whether it's CS2, Fortnite, or PUBG,
3:11always knows exactly where every player
3:13on the map is and what their health is,
3:14even when they're hidden behind walls?
3:16Cheat developers abuse this exact design
3:18flaw. We just need to tell our app to
3:19pull this information out of the game
3:21and use ImGui to draw boxes and lines
3:24over the players using that data. To
3:25extract this from the game, you need to
3:27use something called offsets. Offsets
3:29are just numbers, but they are written
3:31in a hexadecimal format instead of the
3:33typical decimals we use every day.
3:35Hexadecimal is just a different way for
3:36computers to read numbers. For example,
3:38the number 15 is written as 0x F, and
3:40the number 255 is written as 0xFF. These
3:44offsets are different for every single
3:45game, and they change every single time
3:47a game updates. If a new update drops,
3:49you have to find the new offsets, or the
3:51cheat won't work. You need offsets for
3:53absolutely everything you want to show,
3:54like player positions, player health,
3:56the location of important items, and
3:58everything else. Now, scroll down until
3:59you find int main. This is the official
4:01starting point of our cheat program,
4:03meaning whatever instructions we put
4:04here will be executed first. Inside you
4:06will see a line that says mem.attach
4:08with cs2.exe
4:10written next to it. This tells our cheat
4:11app to attach itself to Counter-Strike
4:132. We have to attach to the game's
4:14process before we can pull any of that
4:16information or use those offsets we
4:17talked about earlier. If you want to
4:19hack a different game in the future,
4:20this is the exact line where you will
4:22change the name to match that game's
4:23process. Right below that, you will see
4:25mem.getmoduleaddress.
4:27This gets the base address of a specific
4:29game module. For example, in CS2, a file
4:31called client.dll holds all the critical
4:34data, like enemy positions and health.
4:36So, we target that module here to gain
4:38access to everything inside. Just like
4:39the process name, when you move on to
4:41hack other games, you'll need to find
4:43and swap in their specific module base
4:44addresses right here. You might be
4:46wondering how we actually find these
4:47offsets. There are two main ways to do
4:49it. The difficult way is to reverse
4:50engineer the game yourself. Reverse
4:52engineering means pulling the game apart
4:54to figure out exactly how the developers
4:56built it from the inside out. Since
4:57that's a bit too complex for beginners,
4:59we're going to use the easier method, a
5:01dumper. A dumper is an automated tool
5:03that scans the game while it's running
5:05and extracts all the offsets for you
5:06automatically. There are dumpers
5:08available for almost every game out
5:09there. You just have to look for them.
5:11For this video, we're going to use the
5:12CS2 dumper by a2x, and I've linked it in
5:14the description. To use the dumper, make
5:16sure your game is open and running in
5:18the background, then just launch the
5:20dumper like a normal program. Once it
5:22finishes scanning, it will generate a
5:23new folder called output. Go inside that
5:25folder, and you'll find two specific
5:27files we need, offsets.hpp
5:30and client_dll.hpp.
5:33If you open these files up, you'll see a
5:35massive list of all the updated offsets
5:37for everything in the game. All you need
5:39to do is copy everything inside these
5:41files, go back over to Visual Studio,
5:43and paste them right into the matching
5:45offsets.hpp
5:47and client_dll.hpp
5:52files in your project to fully update
5:54your cheat. Once that's done, look at
5:56the top of Visual Studio. Hit that green
5:57play button, and if you followed every
5:59step correctly, your cheat menu will pop
6:01up instantly without a single error. As
6:03you can see, the ESP is fully working.
6:05We have clean boxes, health bars, and
6:07full skeleton ESP drawing right over the
6:09players. You can press the insert key
6:11anytime you want to hide or show the
6:12menu, and if you need to shut it down
6:13completely, just hit the end key to stop
6:15the cheat. But, wait, there are a few
6:16problems we need to address right now.
6:17First, it might look like I just told
6:19you to download a pre-made cheat and hit
6:21run. That is definitely not what's
6:22happening here. I pre-configured the
6:24source code to save us time. I didn't
6:25want to drag you through a boring 1-hour
6:28tutorial of me typing out every
6:29semicolon. The goal of this channel is
6:31to teach you as fast as possible without
6:33wasting your time. I'm not ending the
6:34video here. We're going to dive straight
6:36into the code right now, so you can
6:37understand exactly how it works and
6:39actually learn the logic. The second
6:41problem is that the menu is currently
6:42non-functional. All the features you see
6:44on the screen, the boxes, the health,
6:45the skeletons, are active right now, but
6:47toggling the buttons in the menu doesn't
6:49actually turn them on or off yet. I
6:51intentionally left it this way, so I can
6:52show you how to wire them up yourself.
6:54By the time we finish this video, you
6:55will fully understand how cheat logic
6:57connects to a menu and how you can apply
6:59this to any game you want. Let's start
7:00by customizing the menu itself. Inside
7:02that same int main function, scroll down
7:04until you find the word begin suggests,
7:06this is where our menu UI actually
7:07starts. We are basically telling ImGui
7:10to create a new window for us. The text
7:12inside the quotation marks here is what
7:13appears as the title at the top of our
7:15menu screen. If you want to personalize
7:17this and give it your own name or your
7:19community's name, just change the text
7:20inside these quotes. As soon as you edit
7:22it and hit run again, you can see the
7:24title changes instantly. The code right
7:26below that handles the sidebar tabs you
7:27see on the left side of the menu. You
7:29can see all the existing tabs listed out
7:31right here. If you want to add a brand
7:32new tab, just add a new line to this
7:34list following the exact same format.
7:36You can also delete any tabs you don't
7:38want. The only thing you need to
7:38remember is to update the the right
7:40above it. Change that I less than four
7:42count to match whatever your new total
7:43number of tabs is, or the menu won't
7:45render them all correctly. And just like
7:47that, we have a new tab. As you can see,
7:49the new tab we just created is
7:50completely empty. Let's fill it up. To
7:52do that, scroll down until you see the
7:54code for ImGui I colon colon begin child
7:57main content. This is the section
7:59responsible for displaying the actual
8:00buttons and settings for whichever tab
8:02you click on. If you look closely at the
8:04logic, you'll see it starts with if
8:06active tab equals zero, which holds all
8:09the features for very first tab, the
8:11aimbot. Below that, else if active tab
8:13equals one handles the second tab, which
8:15is the ESP. Following this exact same
8:18pattern, we can add contents for our new
8:19tab. Since this is our fifth tab, we're
8:21going to write else if active tab equals
8:23four. We use the number four because in
8:25programming, counting always starts from
8:27zero, not one. So, tab one is zero, tab
8:30two is one, and our fifth tab is four.
8:32Let's start by adding some text to our
8:34new tab. To save time, I'll just copy
8:35the text layout code from the previous
8:37tab. First, look at the set window font
8:39scale line. This exactly controls the
8:41size of the text. You can increase or
8:42decrease this number to change the
8:43scale. For a main heading, you'll want
8:45to use a larger font size. Just make
8:47sure that right after your heading, you
8:48add another scale line to lower it back
8:50down so that all the regular text and
8:52options you create below it stay at a
8:53normal, smaller size. To actually
8:55display the words on the screen, you use
8:57the instruction ImGui UI double colon
9:01text. Inside the parentheses and quotes,
9:03you can type absolutely anything you
9:05want, and ImGui will draw it onto your
9:07menu instantly. Now, you want to give
9:09your users some actual options to toggle
9:11the features of your cheat on or off. To
9:12do that, we use a UI element called a
9:14checkbox. Before we add the visual
9:16checkbox to the menu, we need to create
9:18a place in memory to store its state. To
9:20do that, we're going to create a bool
9:21variable. A variable is just a container
9:23that holds data for us, so we can use it
9:25later. In this case, a bool is short for
9:27boolean, meaning it can only hold two
9:29values, true or false. We will use this
9:31variable to track whether our cheat
9:32feature is turned on or off. If this
9:34sounds a little complicated right now,
9:35don't worry. Just follow these next few
9:37steps and you'll see exactly how it
9:39connects. To create a bool variable,
9:41type out the code exactly as you see
9:42here. You can choose any name you want
9:44for this container. In this example,
9:46I've named it option, but feel free to
9:48call it whatever makes sense to you.
9:49Now, let's link it to the menu. To
9:51create the actual visual checkbox, type
9:53ImGui double colon checkbox. Inside the
9:55quotation marks, type the text you want
9:57to appear next to the box in your menu.
9:58Right after that text, we need to pass
10:00in our bool variable with an ampersand,
10:02exactly like I've done here. This tells
10:03the menu to automatically change our
10:05variable to true when the box is checked
10:07and false when it's unchecked. Another
10:09common feature is a slider, which is
10:10perfect for adjusting values like aimbot
10:12speed or FOV radius. To make one, use
10:15the ImGui double colon slider float
10:18function. We need a float variable to
10:19store the value, which just means a
10:21number with decimal points like 0.1 or
10:245.5. When you call the function, pass in
10:26the text label, your float variable, and
10:28then specify the minimum and maximum
10:29values to set the exact boundaries for
10:31the slider. Let's run it, and as you can
10:33see that we have a slider.
10:36Now, scroll up until you find the void
10:37hack game function. As the name
10:38suggests, this is the actual core code
10:40responsible for everything we discussed
10:42earlier. In short, this function uses
10:44your offsets to pull live data straight
10:46out of the game's memory and then tells
10:47ImGui exactly where to draw the ESP
10:50lines, boxes, and player skeletons on
10:52your screen. The very first thing this
10:54function does is get the entity list and
10:56the view matrix. The entity list is a
10:57specific section of the game's memory
10:59that contains the live data for every
11:00single player on the map. We need to
11:02target this list so our app can pull the
11:04locations and health of our enemies.
11:05But, there's a catch. Your computer
11:07monitor is a flat 2D screen. When you
11:09play a 3D game, the engine uses clever
11:11math to create the illusion of depth on
11:13that flat surface, just like drawing a
11:143D cube on a flat piece of paper.
11:16Because the player coordinates we pull
11:18from the game are in 3D space, we have
11:19to convert them back into flat 2D screen
11:21coordinates, so our ESP knows exactly
11:24where to draw. To do that conversion, we
11:25use the game's view matrix. Next, the
11:27function gets the local player. Local
11:28player simply means you, the person
11:30playing the game, not your enemies or
11:32your teammates. We need to grab our own
11:33player data so we can find our specific
11:35team ID. We use this team ID to filter
11:37out teammates so our cheat only targets
11:39the enemies. If we skip this step, the
11:41app won't know the difference and will
11:42draw ESP boxes or lock aimbots onto your
11:45own team. Scroll a bit further down and
11:46you will see the lines where the app
11:48reads the health and team ID of each
11:50player it finds. Right below that, you
11:52can see the exact conditional logic that
11:53compares the player's team ID against
11:55our own local player team ID. If they
11:57match, the code skips them entirely,
11:59ensuring the cheat stays focused
12:01strictly on the enemy team. Next, we
12:02need one last piece of data before we
12:04can actually draw our ESP, and it's the
12:07most important thing of all, the exact
12:08position of the players. To get this, we
12:10access something called the bone array.
12:12The bone array is a specific part of the
12:13game's memory that holds the live 3D
12:15coordinates for every single bone in a
12:17character's body. We need this data to
12:18pinpoint exactly where our enemies are
12:20standing so we can track them through
12:21walls and draw an accurate skeleton ESP
12:24over them. In fact, the entire ESP and
12:26the aimbot completely rely on these
12:27positions. You literally cannot make a
12:29cheat if you don't know where the
12:30enemies are. That's the whole point of
12:32an ESP, and this code does just that for
12:34us. Once we have that bone array data,
12:36we hit the final step before drawing.
12:37Like we discussed earlier, these bone
12:39positions are stored by the game in 3D
12:40space. So, we pass them right into our
12:42world to screen function, which handles
12:44the math to convert those 3D coordinates
12:46into flat 2D positions on your monitor
12:48so our ESP hack can draw the lines
12:50perfectly in place. Next up is our
12:52aimbot logic. For a good aimbot, you
12:54don't want your crosshair randomly
12:56snapping to players all the way across
12:58the map. You want it to target the enemy
13:00within your FOV radius and closest to
13:02your actual crosshair. This section of
13:04the code handles that math for us,
13:05constantly checking the distances and
13:07finding the perfect target. The
13:08remaining blocks of code below this are
13:10simply responsible for the actual
13:12drawing. We use the overlay double
13:13colon's box and line functions to
13:15instantly render the bounding boxes,
13:17lines, and health bar ESP directly onto
13:19your screen based on all that data we
13:21collected. Now, if you want to change
13:22the color of your ESP features, it's
13:24incredibly easy. Just search for an RGB
13:27color picker on Google, dial in whatever
13:28custom color you want, and copy the RGB
13:31values it gives you. Then come back to
13:32the code and look for IM_COL32.
13:35Inside the parentheses, you can just
13:37paste your new RGB values right over the
13:39old ones. The fourth and final number in
13:41that function represents the
13:42transparency. You can tweak it if you
13:44want your ESP to look a bit more
13:45see-through, but I'm going to leave it
13:47exactly as it is for now. And as you can
13:49see, we have changed our box ESP color
13:51to red. Now, let's look at how the
13:53aimbot actually works. Since we already
13:55know the exact location of the enemies,
13:56we simply need to tell our mouse to move
13:58until the enemy is locked directly onto
14:00our crosshair. And since the crosshair
14:01in almost every game is always perfectly
14:04at the center of the screen, the math
14:05becomes straightforward. While the
14:06previous code we looked at was strictly
14:08responsible for finding the absolute
14:10best target nearest to our crosshair,
14:12this block of code right here takes that
14:14target's position and actually moves our
14:15mouse until the enemy is perfectly
14:17centered on the screen. Now, let's
14:19actually make our menu functional so our
14:20cheat features only turn on or off when
14:22we toggle them on the screen. Go back to
14:24our main function where the tab code
14:25lives. As you can see, we created a
14:27checkbox linked to a bool variable
14:28called enable_aim, that is for our
14:30aimbot toggle. Below it, we have our
14:32sliders for the aim smoothing and the
14:34FOV radius, plus a combo box for
14:36selecting exactly which bone of the
14:37enemy we want to target. Right now,
14:39these variables are trapped inside our
14:40main function. To use them inside our
14:42hacking logic, highlight these
14:43variables, press control X to cut them,
14:45and then scroll all the way to the top
14:46and paste them right before our hack
14:48game function. This turns them into
14:49global variables, meaning they can now
14:51be read and used anywhere in our entire
14:52project, including inside our hacking
14:54loop. Next, let's head right back into
14:55our aimbot code that we just discussed.
14:57Now that our variables are global, we
14:58can finally utilize them here. First,
15:00we're going to take enable_aim and wrap
15:02our entire aimbot logic inside an if
15:04statement checking for this variable. As
15:06you can see, by doing this, our aimbot
15:08will remain completely idle and won't
15:09execute a single line of code until we
15:11actually toggle it on using the checkbox
15:13in our menu.
15:17All right, let's hook up the sliders and
15:19the body part selection for the aimbot.
15:21To do that, we just need to swap out the
15:23hard-coded numbers in our code. Find
15:25where the aimbot FOV radius is set and
15:27simply replace that static value with
15:29our sliders variable. We do the exact
15:31same thing for the aim smoothing value,
15:32as well. Now, whenever you slide those
15:34bars on your menu, the cheat will
15:35instantly update in real-time. Next, for
15:37the aimbot bone selection, we can use
15:39simple if conditions to check exactly
15:41what the user picked in the combo box.
15:42If the selected bone variable equals
15:44zero, it means the head is selected, so
15:46we assign the head bone's ID to our
15:48target variable. If it equals one, the
15:49neck is selected. And if it equals two,
15:51then that means the body or pelvis is
15:53selected. Remember, as I told you
15:55earlier, counting the order of elements
15:56in programming always starts with zero,
15:58which is why our options go from zero to
16:01two. I am also going to remove the chest
16:02option from the combo and replace the
16:04pelvis option to body, so it's easier
16:07for the users to understand. Now, let's
16:09check how everything is working.
16:45As you can see, everything is working
16:46perfectly. Now, let's fix the very last
16:48thing, which is our ESP options. The
16:50first thing I'm going to do is rename
16:52our name ESP option to skeleton ESP
16:55instead, because we don't actually have
16:57a name ESP in this build. When you
16:58change a name like this, you also need
17:00to make sure to rename its variable
17:01everywhere it is used in the project, or
17:03your compiler will throw errors. While
17:05we are at it, let's create a brand new
17:06bool variable in that same global area,
17:08which we'll use for toggling our health
17:10ESP on or off. Watch closely as I rename
17:12the variable across the code to clear
17:13out these red error lines, and then we
17:15will quickly create a brand checkbox in
17:17the menu for the health ESP.
17:25Next, we just need to link these new
17:26variables to the drawing logic inside
17:28our hack game function. Scroll to the
17:29code for the skeleton ESP. I'll simply
17:31wrap this in an if statement, just like
17:33we did with the aimbot, to check if our
17:34skeleton ESP variable is true. We'll
17:36place our overlay double colon's line
17:38functions right inside it. Our skeleton
17:39hack also draws a red circle for the
17:41enemy's head, so we need to make sure
17:42that circle is wrapped inside this exact
17:44same if statement. So, it only draws
17:46when the user wants the skeleton
17:47visible. Finally, I'll do the exact same
17:49thing for the bounding box and the
17:50health bar ESP code, wrapping them in
17:52their own toggle. And now, when we hit
17:54run, you can see absolutely everything
17:56working smoothly and responding to the
17:58menu dynamically in real time.
18:01And that is how you make your very first
18:03cheat. Now, your next step is to take
18:04everything I've taught you today and
18:06start experimenting. Try changing things
18:08around, tweak the colors, adjust the
18:10sliders, or try adding a brand new tab
18:12to the menu by playing with the code.
18:14Breaking things and figuring out how to
18:15fix them is exactly how you truly learn.
18:18And remember, if you want to hack any of
18:19your favorite games in the future, the
18:20core rules remain exactly the same. No
18:23matter the game, your workflow is always
18:24going to be find the entity list, grab
18:26the view matrix, locate the player
18:28position offsets, pass them through a
18:29world to screen function, and then use
18:31your overlay to draw the lines and boxes
18:33on top of them. This foundational logic
18:34never changes.

About this transcript

This page contains the full transcript of Learn To Make CHEATS for any GAME in 18 Minutes by BranchLink, generated from the public captions YouTube serves with the video. The transcript has 4,266 words across 606 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.