What Is Cheat Engine, and How Does It Actually Work?

The name Cheat Engine makes the software sound wonderfully simple.

Install it. Press the large red CHEAT button. Become immortal. Defeat the final boss. Retire somewhere warm.

Unfortunately, no such button exists.

Cheat Engine is not a magical catalogue of ready-made cheats for every game. It is a powerful memory-scanning and debugging tool that lets users inspect—and sometimes modify—the data used by a program while it is running.

In practical terms, it can help you find where a single-player game stores values such as health, ammunition, money, movement speed, timers, or experience points. Once the correct location has been identified, you may be able to change the value, freeze it, trace the code that updates it, or build a reusable cheat table.

That sounds suspiciously like hacking because, technically, it is a form of software analysis. However, the same fundamental techniques are also useful for modding, debugging, accessibility experiments, reverse-engineering practice, and understanding how games work behind the beautiful textures and emotionally unavailable NPCs.

Cheat Engine’s official project describes it as a development environment focused on modifying games and applications for personal use. Its official website also states that it is intended for private and educational purposes and warns users to respect the terms of service or end-user licence agreement of the software they inspect.

So what exactly happens when Cheat Engine changes your gold from 126 to 999,999?

To understand that, we need to talk about memory.

Games Are Constantly Remembering Things

When a game is running, it needs somewhere to keep all the information required at that moment.

That information may include:

• Your current health
• The ammunition inside your weapon
• Your character’s position
• The number of coins in your inventory
• The enemy’s health
• The remaining mission time
• Whether a door has been opened
• Whether your character is poisoned
• How many chickens you have offended

Much of this temporary working data is stored in the computer’s random-access memory, commonly called RAM.

The game executable contains instructions and assets, while save files preserve selected information for later. RAM, meanwhile, functions more like the game’s active workspace. It contains information that the game needs to access and update quickly while it runs.

Imagine a role-playing game in which your character currently has 100 health.

Somewhere in the game’s memory, there may be a location containing the numerical value 100. When an enemy attacks you for 12 damage, the game executes instructions that change that value from 100 to 88. The interface then reads the updated information and redraws your health bar.

The simplified process looks like this:

Stored health: 100 → Enemy attacks → Stored health: 88 → Health bar updates

Cheat Engine attempts to locate that stored value among the enormous amount of data belonging to the running game.

The difficulty is that 100 may appear thousands—or millions—of times in memory.

It could represent your health, an enemy’s health, a menu coordinate, an item identifier, a sound setting, a percentage, part of a colour value, or the game’s internal measurement of how many times you have ignored the tutorial.

Cheat Engine therefore does not normally identify the correct value immediately. It narrows the possibilities through repeated scans.

Also read: Slormancer Cheat Engine Guide: How I Broke the Grind and Had More Fun

Cheat Engine Is Primarily a Memory Scanner

Memory scanning means searching the memory of a selected process for a particular value or pattern. Cheat Engine performs an initial scan and produces a list of matching memory addresses. Further scans can then reduce that list according to how the target value has changed.

Suppose a single-player game displays your health as 100.

You could begin by telling Cheat Engine:

Find every location containing the number 100.

The first scan might return 42,000 results.

That is not particularly helpful unless you enjoy manually testing numbers until the sun expands and consumes the Earth.

You therefore return to the game and deliberately take damage. Your health falls to 83.

Then you tell Cheat Engine:

From the previous results, keep only the addresses that now contain 83.

The list may shrink from 42,000 results to 24.

You take damage again. Your health becomes 71.

Another scan for 71 may reduce the list to one or two addresses.

At that point, you can test a candidate address by changing its value. If setting it to 500 gives your character 500 health, congratulations: you have probably found it.

Your résumé may now include “junior memory archaeologist.”

A Memory Address Is Like a Temporary House Number

Every value in memory exists at a location known as an address.

An address may appear as something like:

1F7A3C90

or:

7FF6A2B84C10

These values are commonly shown in hexadecimal notation. You do not need to perform hexadecimal arithmetic merely to understand the basic concept. For now, think of an address as a house number inside the game’s virtual neighbourhood.

Cheat Engine searches those houses for the value you want.

When it finds the right one, it can read the value stored there and, where permitted, write a different value into the same location.

Windows provides mechanisms through which one process can inspect or modify another process’s virtual memory when it has the necessary access rights. Relevant Windows functions include VirtualQueryEx, which retrieves information about regions in another process’s virtual address space, along with memory-reading and memory-writing functions such as ReadProcessMemory and WriteProcessMemory.

Cheat Engine provides a much friendlier interface for this kind of work. “Friendly” is relative, of course. Its interface still looks like an accounting application that became interested in cybercrime.

A Real Example: Changing Money in an Offline Game

Consider an imaginary offline strategy game called Kingdom of Budget Cuts.

You currently have:

2,450 gold

You purchase a defensive tower for 300 gold. Your balance becomes:

2,150 gold

Here is the basic memory-scanning logic.

Step 1: Select the Game Process

Every running application exists as a process. Cheat Engine must be attached to the correct game process before it can inspect that program’s memory.

If you attach it to the calculator instead, your kingdom’s economy will remain unchanged, although Windows Calculator may become extremely wealthy.

Step 2: Search for the Current Value

You enter 2450 and perform an Exact Value scan.

Cheat Engine searches the process memory for locations containing that number.

Step 3: Change the Value Naturally

You return to the game and spend 300 gold.

The game updates its internal value to 2150.

Step 4: Perform a Next Scan

You enter 2150 and perform another Exact Value scan.

Cheat Engine checks the previous candidates and keeps only those now containing 2150.

Step 5: Repeat When Necessary

If several results remain, you buy or earn something else and scan again.

Eventually, one address may consistently follow the displayed gold value.

Step 6: Test the Address

You add the candidate address to Cheat Engine’s address list and change it to 999999.

If the in-game balance changes accordingly, the address is probably correct.

This example works best when the game stores its money as a straightforward integer on the local machine. Many games do. Many others absolutely do not, because game developers have also discovered Google.

Also read: Cheat Engine AOB Scripting Tutorial: Unlock Hidden Game Mechanics

Values Are Not Always Stored the Way They Look

One of the biggest beginner mistakes is assuming that a displayed number must be stored in memory in exactly the same form.

A game showing 100 health might store it as:

• The integer 100
• The floating-point value 100.0
• The value 1.0, representing 100 percent
• The value 10000, using an internal multiplier
• A current-health value combined with a separate maximum-health value
• An encoded or obfuscated number
• A value calculated from several other variables
• A server-side value that is not authoritative on your computer at all

This is why Cheat Engine supports multiple value types.

Common examples include:

1 Byte

A small integer occupying one byte of memory.

It can be useful for small counters, status flags, booleans, or values with a limited range.

2 Bytes

A larger integer format that can represent more possible values than a single byte.

4 Bytes

One of the most common starting points for ordinary whole numbers such as health, money, ammunition, and item quantities.

Cheat Engine’s own tutorials frequently begin with 4-byte integers when searching for visible whole-number values.

8 Bytes

A larger integer type useful when values exceed the range of a 4-byte integer or when the program deliberately uses a wider format.

Float

A floating-point number commonly used for values with decimals, including coordinates, speed, timers, percentages, physics properties, and health systems requiring fractional precision.

A timer that visibly displays a whole number, for example, may still be stored internally as a float.

Double

A higher-precision floating-point format.

String or Text

Used when searching for actual text rather than a numerical quantity.

Array of Bytes

A sequence of raw bytes, often called an AOB pattern. This becomes useful in more advanced work, particularly when searching for instruction patterns that may remain recognisable even when addresses move.

Choosing the wrong value type can produce no results—or worse, thousands of results that confidently lead nowhere.

Cheat Engine is very powerful, but it still requires the user to make reasonable guesses. It is less like asking an all-knowing oracle and more like interrogating a database that deeply resents eye contact.

What Happens When You Change a Value?

Suppose you have found the memory address holding your ammunition count.

The game says:

Ammo: 12

Cheat Engine reads the address and also sees:

12

You replace it with:

999

Cheat Engine writes 999 into that location. The next time the game checks the ammunition value, it sees 999 and updates the interface.

Nothing supernatural happened. The game simply trusted the data currently stored in its own memory.

This distinction is important.

Cheat Engine does not necessarily modify the game’s original executable file. A basic value edit normally changes information inside the running process. Once the game closes, that memory is released.

That is why many simple edits disappear when you restart the game.

You changed the game’s temporary thoughts, not its permanent personality.

What Does “Freezing” a Value Mean?

Cheat Engine can also freeze an address.

Suppose your health is stored at an address containing 100.

When you freeze it, Cheat Engine repeatedly forces that address to retain the chosen value. The game may attempt to reduce it after an attack, but Cheat Engine writes the frozen value back.

Conceptually:

Game writes 80 → Cheat Engine restores 100 → Game writes 65 → Cheat Engine restores 100

This can create the familiar effect of unlimited health, ammunition, money, or time.

However, freezing does not always work cleanly.

The game might:

• Use another copy of the value
• Recalculate it from a different variable
• Update it more quickly than expected
• Detect that the value is invalid
• Trigger an event only when its own code performs the change
• Crash because the frozen number violates an assumption

Setting your inventory capacity to two billion may sound efficient until the game attempts to create two billion inventory slots and your PC begins writing its final will.

Exact Value Is Only the Beginning

You do not always know the number you are trying to find.

Perhaps the game displays health as a bar without showing a numerical value. You know the bar became shorter, but you do not know whether the internal health changed from 347.8 to 291.4, from 1.0 to 0.84, or from Healthy to Slightly More Dead.

This is where Unknown Initial Value scanning becomes useful.

Instead of searching for a specific number, you ask Cheat Engine to record a broad collection of possible values.

You then make something happen in the game and narrow the results according to their behaviour.

Cheat Engine supports scan filters including:

• Increased value
• Decreased value
• Changed value
• Unchanged value
• Increased by a specific amount
• Decreased by a specific amount
• Bigger than
• Smaller than
• Value between two numbers

These filters allow users to find values based on how they change, even when the exact number is hidden.

For example, when searching for an invisible stamina value:

1. Begin with Unknown Initial Value.
2. Sprint and scan for Decreased Value.
3. Stand still and scan for Increased Value.
4. Wait after stamina becomes full and scan for Unchanged Value.
5. Sprint again and scan for Decreased Value.

Each scan eliminates values that did not behave like stamina.

Eventually, the list becomes manageable.

It is basically a game of “Guess Who?” except every character is a memory address and most of them are lying.

Why Does the Address Change After Restarting the Game?

You find your money address.

You save it.

You restart the game.

The address now contains nonsense.

This is normal.

Modern operating systems and applications use dynamic memory allocation. Data structures may be loaded into different locations each time a game runs. Address Space Layout Randomization and differences in allocation order can also contribute to changing locations.

The value is still somewhere in memory, but it has moved into a new apartment without leaving a forwarding address.

A directly discovered address is therefore often temporary.

To create a more reliable cheat, users commonly look for:

• Static addresses
• Module-relative addresses
• Pointer paths
• Code that accesses or writes the value
• Stable byte patterns
• Reusable injection points

A pointer is a value that stores another memory address. A chain of pointers can provide a repeatable route to a dynamically allocated value.

For example:

Game module + fixed offset → player object → statistics object → health

The final health address may change after every restart, but the route leading to it may remain stable.

Cheat Engine includes a pointer scanner that can search for possible paths to a target address. A common method involves scanning once, restarting the game, finding the relocated value, generating another pointer map, and comparing the results to eliminate invalid paths.

Pointers deserve their own article because explaining them properly requires diagrams, patience, and at least one metaphor involving apartment buildings.

For now, remember this:

The value may move, but something else may still know where it lives.

Cheat Engine Can Watch the Game’s Instructions

Changing a value is only the first level of Cheat Engine.

The software also includes debugging and disassembly tools that can reveal which machine-code instructions read from or write to a particular memory address.

After finding a health address, for example, you can use options such as:

• Find out what writes to this address
• Find out what accesses this address

Cheat Engine places a breakpoint and records instructions interacting with the chosen address while the program runs.

Suppose your health decreases whenever this instruction executes:

sub [rdi+30],eax

In simplified terms, that may mean:

Subtract the damage amount from a value located at an offset of 30 inside an object referenced by the RDI register.

At this stage, you are no longer merely locating a number. You are investigating the code responsible for changing it.

That opens the door to more advanced modifications, such as:

• Preventing damage
• Multiplying earned currency
• Changing movement speed
• Redirecting an instruction
• Injecting custom code
• Distinguishing the player from enemies
• Building scripts that work after restarting the game

It also opens the door to accidentally making every enemy invincible because the same instruction controls health for all characters.

Cheat Engine’s documentation specifically demonstrates that one instruction may affect both the player and other actors. A proper script may therefore need to identify which object belongs to the player before changing the behaviour.

“No damage” sounds wonderful until you discover you have also protected the boss.

Cheat Tables Turn Experiments Into Reusable Tools

A cheat table is a file that stores information about discovered addresses, pointers, scripts, descriptions, hotkeys, and other modifications.

Rather than repeating the entire scanning process every time, you can load a table and activate the desired options.

A table may include entries such as:

• Unlimited health
• Unlimited ammunition
• Money multiplier
• No crafting requirements
• Movement-speed modifier
• Experience multiplier
• Freeze mission timer
• Player coordinates
• Inventory editor

Simple tables may contain direct addresses. More advanced ones use pointers, AOB scans, assembly scripts, and Lua.

Cheat Engine includes an Auto Assembler, disassembler, debugger, hex viewer, memory viewer, code dissector, and other advanced facilities.

At that point, Cheat Engine becomes less of a “cheat program” and more of a compact reverse-engineering workshop.

The name undersells it slightly.

Then again, Interactive Runtime Memory Inspection and Software Modification Environment probably would not fit neatly under the desktop icon.

What Else Can Cheat Engine Do?

Although memory scanning is its most recognisable feature, Cheat Engine supports several other capabilities.

Speedhack

Cheat Engine’s speedhack can make some games or applications run faster or slower by altering how they perceive time-related functions.

It does not accelerate your internet connection, make a remote server process events faster, or convince a download to respect your impatience. The official documentation explicitly notes that it does not change physical processes or the experience of other users connected to a server.

Speedhack can be useful for:

• Skipping slow traversal
• Accelerating repetitive animations
• Slowing difficult timing sections
• Testing time-dependent mechanics
• Practising speed-sensitive sequences
• Taking cleaner screenshots

Its effectiveness varies because different games handle time in different ways.

Structure Dissection

Games commonly organise related data into structures or objects.

A player object might include:

• Health
• Maximum health
• Stamina
• Position
• Character identifier
• Movement speed
• Status flags
• Equipment references

Cheat Engine can help users inspect memory regions and compare related objects. This may reveal patterns, offsets, and relationships between values.

Code Injection

Cheat Engine’s Auto Assembler can allocate memory, insert custom instructions, redirect execution, and restore original code when a script is disabled.

This is significantly more advanced than changing a number. It requires an understanding of assembly language, registers, instructions, memory safety, and the game’s logic.

Copying random injection scripts from strangers is therefore an excellent way to turn “unlimited ammunition” into “unlimited crashes.”

Lua Scripting

Cheat Engine supports Lua scripting for automation, interfaces, hotkeys, memory operations, and more complex table behaviour. Its documentation exposes functions for writing several kinds of values into a target process.

Lua can be used to create polished trainers or tools that hide much of Cheat Engine’s intimidating machinery behind buttons and menus.

Why Cheat Engine Works Better in Some Games Than Others

Cheat Engine is generally easiest to use when:

• The game is offline
• Important data is stored locally
• Values are stored plainly
• There is no integrity checking
• The game does not frequently reconstruct its data
• The target uses conventional native code
• The game has no active anti-cheat protection

It becomes more difficult when:

• Values are encrypted or obfuscated
• Multiple copies of a value exist
• The displayed value is only cosmetic
• The authoritative value is stored on a server
• The game verifies values through checksums
• Data is recalculated constantly
• Code is generated or transformed at runtime
• An anti-cheat system blocks debugging or memory access
• The game uses unusual virtual machines or managed runtimes
• Updates frequently change the relevant code

For example, changing a locally displayed currency value in an online game may only alter the number shown on your screen.

The server still knows you have 200 coins.

You attempt to buy a 10,000-coin item.

The server responds with the digital equivalent of:

That is adorable.

The purchase fails because the server—not your local interface—controls the authoritative balance.

This client-server distinction is one of the most important limits of memory editing.

Cheat Engine Is Not the Same as a Save Editor

A save editor modifies data stored in a save file.

Cheat Engine primarily interacts with a running process.

The distinction looks like this:

Cheat Engine

• Works with live memory
• Can observe values changing in real time
• Can inspect code and data structures
• Can freeze or manipulate temporary values
• Can create scripts triggered while the game runs

Save Editor

• Modifies persistent save data
• Usually works while the game is closed
• Requires knowledge of the save-file format
• May alter inventory, progress, statistics, or quest state
• Does not normally inspect the game’s live instructions

Sometimes the two approaches overlap. A value edited in memory may later be written into the save file. In other situations, the game rejects the modified value or recalculates it during saving.

Both approaches can also corrupt progress.

Back up your saves.

This is not optional wisdom passed down by cautious elders. It is a warning written in the tears of everyone who changed a quest flag from 0 to 47.

Is Cheat Engine Legal?

There is no single universal answer covering every jurisdiction, game, licence agreement, and use case.

Using memory-analysis tools on software you own for personal experimentation is very different from:

• Circumventing paid content
• Manipulating online economies
• Selling cheats
• Interfering with other players
• Bypassing access controls
• Defeating anti-cheat systems
• Modifying competitive results
• Violating a game’s terms of service

Even when an activity is not criminal, it may still violate a game’s EULA or terms of service and result in account suspension or a permanent ban.

Cheat Engine’s own website tells users to verify that attaching it to a game does not violate that software’s rules.

A useful practical rule is simple:

Keep experiments offline, private, and away from competitive or shared environments.

Changing the difficulty of your own single-player game affects you.

Giving yourself perfect aim in a ranked match affects everyone else, including several people who merely wanted to relax after work and are now reconsidering humanity.

Can Cheat Engine Get You Banned?

Yes.

Launching Cheat Engine while an anti-cheat-protected game is running may be enough to trigger detection, block the game, or create account risk. The exact behaviour depends on the game and its anti-cheat implementation.

Even when you do not actively modify the online game, security software may view memory scanners, debuggers, process manipulation, or injection capabilities as suspicious.

Therefore:

• Do not attach Cheat Engine to online competitive games.
• Do not leave it running when launching anti-cheat-protected software.
• Do not assume that “I only opened it” will satisfy an automated detection system.
• Do not test on an account you care about.
• Do not seek anti-cheat bypasses.

The safest environment is an offline game with no multiplayer component and no active anti-cheat service.

Why Antivirus Programs Sometimes Flag Cheat Engine

Cheat Engine performs actions that resemble techniques used by malicious software.

It can:

• Inspect another process’s memory
• Modify memory
• Attach a debugger
• Inject or redirect code
• Allocate memory inside a target process
• Manipulate execution
• Create scripts that automate those operations

Those capabilities are legitimate in debugging and modding contexts, but they also overlap with behaviours associated with malware. Security tools may therefore classify Cheat Engine or its installer as potentially unwanted, risky, or suspicious.

This does not mean that every detection should automatically be ignored.

The correct response is not:

Antivirus complained, but a person named XxDragonSlayer1997xX said it was fine.

Download software only from its official project sources, carefully inspect installer options, avoid random mirrors, and treat unexpected bundled software or modified builds with suspicion.

Cheat Engine is open source, and its official repository is publicly available.

Still, “open source” does not magically authenticate every executable bearing the same name. A counterfeit download can remain counterfeit even while the genuine project’s source code is public.

Is Cheat Engine Only for Cheating?

Not really.

The software can also serve as a gateway into several technical subjects:

• How programs use memory
• Integer and floating-point representation
• Pointers and offsets
• Assembly language
• Debugging
• Data structures
• Software architecture
• Reverse engineering
• Scripting
• Game logic
• Client-server design
• Basic software security

A beginner may start by changing a health value.

Then they notice the address moves.

That leads to pointers.

Pointers lead to data structures.

Data structures lead to assembly instructions.

Assembly leads to code injection.

Three weeks later, they are explaining CPU registers during dinner while everyone else quietly stops inviting them.

Cheat Engine offers an unusually visual way to learn these ideas because changes produce immediate, observable effects inside a game.

Modify the wrong value, and the game crashes.

Modify the right value, and your character jumps into the stratosphere.

Both results are educational.

One is simply more aerodynamic.

What Cheat Engine Cannot Reliably Do

Despite its reputation, Cheat Engine cannot automatically:

• Generate working cheats for every game
• Modify authoritative server-side values
• Guarantee that edits survive a restart
• Prevent anti-cheat detection
• Understand what every address represents
• Repair a corrupted save
• Make unsafe values safe
• Replace knowledge of programming and debugging
• Turn every table found online into trustworthy software
• Make you good at the game in any spiritually meaningful sense

It is a tool.

A very capable one—but still a tool.

A hammer can build furniture, remove a nail, or introduce a laptop to the afterlife. The outcome depends heavily on the operator.

The Simplest Explanation of How Cheat Engine Works

At its most basic, Cheat Engine follows this process:

1. Attach to a running program.
2. Search its memory for a value.
3. Change something inside the program.
4. Scan again to eliminate incorrect results.
5. Repeat until the likely address is found.
6. Read, modify, or freeze the value.
7. Trace the code or pointers behind it when a more durable solution is needed.

That is the central idea.

The advanced features—debugging, pointers, assembly, AOB scanning, injection, Lua, and structure dissection—are extensions of that same investigation.

You begin with:

Where is my health?

Eventually, you arrive at:

Which instruction updates the health field inside this dynamically allocated actor structure, and how can I modify it without affecting NPCs?

This is how hobbies become technical specialisations.

Final Thoughts

Cheat Engine works because games need to store and manipulate information while they run.

Health, ammunition, money, position, timers, speed, and countless other properties exist somewhere in memory or are produced by instructions operating on memory.

Cheat Engine allows users to search that information, observe how it changes, replace it, freeze it, and investigate the code responsible for it.

For a beginner, it can feel like magic.

It is not.

It is memory, data types, addresses, pointers, program logic, operating-system permissions, and an interface containing enough checkboxes to frighten a tax accountant.

That makes Cheat Engine more interesting than a simple cheating utility. Used responsibly in offline software, it can be a practical introduction to how games behave beneath the interface.

And once you understand that, the mysterious health bar stops being a colourful rectangle.

It becomes a number.

Somewhere.

Waiting to be found.