ewwe.
← All posts

The Machine Is Yours

Cheat Engine, Ring 0, hypervisors, and Valve's refusal to turn the PC into a locked-down console.

In this post

Cheat Engine never went away

In 2000, a programmer calling himself Dark Byte wanted a memory editor that worked the way he wanted on Windows 2000. The result was Cheat Engine. Its basic trick remains easy to understand: a game stores values in memory, and Cheat Engine helps a player find them.

Imagine an offline RPG displaying 100 health. Search the running game's memory for the number 100. Get hit; health falls to 73. Narrow the search to locations that now contain 73. Repeat until only a few addresses are left. Change the right value, and the health displayed by the game may change with it. If the exact number isn't known, Cheat Engine can instead filter for values that increased, decreased, or remained unchanged.

That is not magic. It is a search engine for the game's working memory. And it teaches an important fact about software: an address by itself is not a meaning. Somebody still has to discover which bytes represent health, ammunition, location, or something else. Cheat Engine's memory-scanning documentation describes the machinery.

What a cheat table actually contains

A .CT file is a reusable Cheat Engine table, normally XML. It might contain a record labelled Health, a record labelled Money, a pointer path that locates the player object after restarting the game, and scripts that alter instructions rather than merely editing numbers.

Why the pointer? Because finding health at 0x12345678 today does not guarantee it will be there tomorrow. The game might allocate the player object in a new location; address-space layout randomization can move modules; an update can change the structure entirely. A table can instead describe something like:

game.exe + offset → player pointer → stats pointer → health

That is a map, not simply a list of cheat codes. More advanced tables use byte-pattern scans, Auto Assembler, and Lua scripting. They preserve little pieces of reverse-engineering work so the next player does not have to rediscover everything. See Cheat Engine's cheat-table documentation.

And on the doorstep of 2027, it remains useful. Want to cut out grinding in an offline game? Inspect a weird inventory value? Diagnose a broken save or learn what a program is doing? Cheat Engine remains a capable research tool, not a historical curiosity. Its source code is public, and the project includes debugging facilities, kernel components, and DBVM, its own lightweight hypervisor. DBVM's documentation is a reminder that even the supposedly old-fashioned memory editor explored the territory now associated with advanced cheats.

An offline player editing their own RPG is not the same social problem as a player revealing enemy positions in a competitive match. The underlying act—finding and interpreting bytes—can be much the same. The fight starts when the game publisher tries to prevent it.

Ring 3 and Ring 0: different roads to the same memory

Windows separates ordinary applications from the operating system's most privileged code. On x86-64 systems these privilege levels are traditionally described as rings. Most Windows applications, including a game and an ordinary Cheat Engine session, run in Ring 3, or user mode. The Windows kernel and many device drivers run in Ring 0, or kernel mode. Rings 1 and 2 exist in the processor's traditional protection model but are generally unused by Windows. Microsoft explains the user/kernel split here.

Diagram showing Windows rings 3 through 0 and hardware virtualization separate from the rings.

Figure 1. Rings describe privileges, not locations in physical RAM. The hypervisor panel is separate because “Ring −1” is an informal nickname, not a fifth x86 protection ring.

A Ring 3 program cannot just reach into any other process. It normally asks Windows for access. Cheat Engine can use documented process-memory APIs such as ReadProcessMemory, which requires a suitable process handle and permissions. A protected multiplayer game makes that route much harder through access restrictions, integrity checks, and anti-cheat monitoring.

A kernel cheat wants the same information—a coordinate, an entity list, an ammunition count—but approaches it with greater privileges. Instead of asking Windows, as an ordinary application, to read another process, a privileged component can work through kernel memory-management facilities. This is why a kernel cheat is not an alien technology descended from something other than Cheat Engine. It is often the same memory-reading problem approached from a different place in the system.

A driver is powerful, not psychic

Here is the plain-English version of something kernel documentation makes unnecessarily intimidating.

Imagine two apartment buildings, each with an apartment 42. “Apartment 42” isn't enough to tell you which door to open. You need the building too.

Memory addresses work similarly. Two different Windows processes can use the same virtual address while that address points to entirely different physical memory. A driver that receives a bare address does not automatically know which program's memory it refers to. It must use the correct process's address map and check that the memory is valid. Get it wrong and a faulty kernel driver can crash the whole PC instead of merely closing an app.

So yes, Ring 0 has extraordinary authority. No, it does not magically tell the programmer which bytes represent an enemy's head or where a game's player object lives. Cheat authors still have to reverse-engineer structures, follow pointers, and update their work when the game changes. Microsoft's driver guidance on user-space memory is the more formal version of this explanation.

This also explains the anti-cheat escalation. If a cheat controls the kernel while the anti-cheat lives only in user mode, the lower-privilege defender has trouble trusting what Windows reports. Anti-cheat vendors responded with kernel drivers of their own. Cheat developers moved toward vulnerable signed drivers, boot-time tricks, and virtualization. Riot's June 2026 technical report says ordinary internal cheats accounted for less than roughly 10% of its cheat-infected PC ranked matches, with kernel cheating a major remaining category. That statistic covers Riot's titles, not the whole industry, but the direction is unmistakable.

Your PC already has kernel drivers. How many?

Graphics drivers, storage drivers, network drivers, filesystem filters, and security software already run privileged code on Windows. If you want to know how many running driver-service entries your machine reports, open PowerShell and run:

(Get-CimInstance Win32_SystemDriver | Where-Object State -eq 'Running' | Measure-Object).Count

To see the names:

Get-CimInstance Win32_SystemDriver | Where-Object State -eq 'Running' | Select-Object Name, DisplayName, PathName

The result will vary. It counts running Windows driver-service entries, not necessarily every loaded kernel image, and I cannot inspect your PC from here. Microsoft documents the WMI class.

A game's kernel driver is therefore not unprecedented. What deserves debate is whether a game company needs that power, what the driver collects, how it is secured, and whether the user may opt out without losing access to the entire competitive experience.

One established route for unauthorized kernel access is BYOVD: bring your own vulnerable driver. A legitimately signed driver may contain a flaw that lets an attacker obtain privileged capabilities. A valid digital signature tells Windows something about where code came from, not whether the code is safe. Microsoft's vulnerable-driver blocklist is one response, though blocking old drivers can break legitimate hardware and software.

And kernel control is no longer the bottom of the argument.

Hypervisors, VM exits, and why bad code can destroy frame times

The popular phrase Ring −1 refers to a hypervisor, software that manages a virtualized operating system. Technically, Intel VMX root operation and AMD's corresponding host virtualization mode are not additional ordinary x86 rings. But the nickname conveys the essential point: a hypervisor can exercise control over a guest OS that the guest's own kernel does not possess.

A Windows game uses virtual addresses, and Windows translates them into memory pages. Under virtualization, a second translation layer—Intel EPT or AMD NPT—maps the guest's idea of physical memory to the actual physical memory. That gives a hypervisor a possible way to observe guest state without using Windows process APIs.

This is the same old destination by a newer road: discover where the game keeps an object, interpret the bytes, and obtain the information. The extra privilege does not do the reverse engineering for you. It changes who can see the road being taken.

What a VM exit is

Think of a hypervisor as a supervisor letting Windows run directly on the CPU most of the time. The supervisor does not execute every guest instruction one by one. Modern virtualization is fast precisely because ordinary instructions usually run on hardware without interruption.

Some events, however, require the supervisor's attention. The CPU stops running the guest, saves or switches the relevant processor state, and transfers control to the hypervisor. That transition is a VM exit. The hypervisor handles the event—perhaps a privileged instruction, an intercepted register operation, or a configured memory-access event—and uses VM entry to resume the guest.

A simplified sequence is:

Windows running → intercepted event → VM exit → hypervisor handles it → VM entry → Windows resumes

Each detour costs time. Intel describes VM exits and returns as consuming hundreds or thousands of CPU cycles, depending on the hardware and event, before counting all the work the handler itself might perform. See Intel's gaming-workload research on reducing VM exits.

Now put that into a frame budget. At a hypothetical 4 GHz, 2,000 cycles cost about 0.5 microseconds. That sounds negligible. But 5,000 unnecessary exits in one frame would add about 2.5 milliseconds before any expensive handler work. A game targeting 144 FPS has only 6.94 milliseconds per frame. Burn 2.5 ms on virtualization overhead and you've thrown away more than a third of that budget.

Those numbers are an illustration, not a measurement of a particular cheat or anti-cheat. Real costs vary with the processor, what triggered the exit, how much state must be handled, and how efficiently the hypervisor returns to the guest. Intel's published experiment reducing unnecessary halt-related exits reported 4%–71% average-FPS gains across ten games in its tested virtual-machine setup. That's evidence that exit handling can matter enormously—not a claim that all hypervisors impose a 71% penalty.

Can timing expose a malicious hypervisor?

Potentially. Software can measure the elapsed time around operations, and some operations are slower when virtualized or intercepted. A badly implemented hypervisor may leave unusually large delays, inconsistent results, or distinctive timing patterns. That gives a defender something to investigate.

But a fast or slow operation is not a signed confession. Legitimate Hyper-V, Windows virtualization-based security, other virtual machines, CPU scheduling, power management, interrupts, and normal system load can all affect timing. A legitimate machine can show virtualization overhead without running a cheat; a well-engineered malicious hypervisor may make the signal much smaller. Timing is evidence to combine with other checks, not a reliable yes/no oracle.

And even a perfectly concealed memory observer does not automatically conceal what the player does with the information. Server-side analysis can still flag impossible or suspicious behavior. More importantly, the cheat cannot read enemy information that the server never sent to the client.

Windows is joining the anti-cheat war

Modern anti-cheat increasingly asks the machine to prove that it booted and stayed within a particular trusted configuration. That pulls in Secure Boot, the TPM, virtualization-based security, hypervisor-protected code integrity, and IOMMU restrictions on direct memory access.

Microsoft's GetRuntimeAttestationReport is a useful example. It lets a program request a cryptographically authenticated report about measured driver and code-integrity state. Riot's Vanguard On-Demand announcement explains how qualifying Windows 11 systems can use these guarantees so Vanguard's driver need not remain running from every boot.

That is technically impressive. It is also an extraordinary destination for the humble problem of somebody using a wallhack.

We began by editing a number in memory. We arrived at hardware-backed attestations that determine whether a computer is sufficiently trustworthy to play a game.

Security engineers have good reasons to want strong boot integrity and driver isolation. Those protections also defend against malware. But a remotely imposed integrity policy is not the same thing as securing a computer for its owner's benefit. Anti-cheat treats the owner as the potential attacker.

And the owner can still change hardware, use another operating system, attach external devices, or analyze images shown on a monitor. Camera-based and computer-vision cheats underline the limit: some attacks never have to read protected game memory in the first place.

This is why pursuing absolute control of a player-owned PC risks becoming a fool's errand. Every new barrier can raise the attacker's cost. None changes the fact that the computer is in the player's hands.

Valve is trying to solve a different problem

Valve has been criticized for refusing to deploy a comparable always-on, kernel-level anti-cheat in its own Counter-Strike matchmaking. The immediate security argument against Valve is real: user-mode defenses cannot observe a compromised kernel with the same authority as a kernel driver. FACEIT's Counter-Strike platform uses a kernel-mode driver and secure-boot requirements, showing that the same game can be protected under another model.

But perhaps Valve isn't simply losing a race it ought to join. Perhaps it is also working on a different kind of race.

In 2017 Valve introduced Trust Factor matchmaking, using account history and observed behaviors to group people likely to have a good experience together. Valve's current CS2 FAQ says the exact factors remain private and that matchmaking tries to group players with comparable trust, subject to queue size, map, and region.

Think of it as the logic of a recommendation system applied to human opponents. YouTube doesn't need to know the metaphysical truth about a video to decide which viewers are likely to enjoy it. A matchmaker doesn't need absolute certainty about every account to estimate how likely that account is to spoil a match.

Skill can be one bucket; reliability, reports, abandonments, disruptive behavior, and suspicious play can inform others. The exact feature set in Valve's current system is undisclosed. The general idea, however, is clear: contain the harm, rather than attempting to confiscate technical control of the client.

That philosophy has an appealing consequence. You needn't prove that somebody has loaded a particular driver to take their matchmaking risk into account. A consistently disruptive account can receive different matchmaking treatment even where the evidence would not justify a permanent cheating ban.

But there is a dangerous side. Secret trust scores can be wrong. False reports, unusual skill, network problems, and feedback loops can make a legitimate account appear suspicious. A lower-trust pool can become self-reinforcing if players are repeatedly exposed to worse matches. If Valve wants this approach to be a genuine alternative to invasive endpoint controls, it needs safeguards against mistaken classification, ways to recover trust, and meaningful appeal for serious sanctions.

Deadlock: a modding scene thriving in a competitive game

Deadlock makes the argument more interesting—and much more exciting.

Here is a modern competitive game, approaching 2027, with a lively ecosystem of client-side hero skins, model swaps, HUD redesigns, sound replacements, and custom assets. People take apart its presentation and put it back together in their own style. They share their work, build managers for installing it, and even develop unofficial tools because Valve hasn't released a full official modding kit.

This is glorious. In an industry increasingly interested in ensuring that every asset and executable byte is exactly what the publisher shipped, Deadlock players are busy turning their copies into something personal.

The community's Deadlock Mod Manager displays popular skins, HUD and quality-of-life modifications, and sound packs; GameBanana's ecosystem contains thousands of projects. Some of the best-known cosmetic replacements have attracted hundreds of thousands of downloads, according to the mod manager's October 2026 snapshot. Most change only what the installing player sees or hears.

One caveat is essential: Valve has not published a general policy declaring all Deadlock mods officially permitted, and the game has no official modding SDK or Workshop integration as of November 2026. Community documentation describes widespread cosmetic modding but warns that modifications offering a gameplay advantage may violate the rules. The community modding FAQ and independent modding guide make that uncertainty explicit. “People are doing it” is not the same as “Valve promises never to punish it.” And it is November 2026, not yet 2027.

Even with that uncertainty, the present reality is worth celebrating. Players can alter a surprising amount of a live competitive game's look and feel without the entire experience being designed around total file lockdown. Some client files are checked and gameplay-affecting changes can be blocked; there is no credible basis for claiming anything goes. But the existence of a flourishing modding scene points to the PC tradition that security discussions too often forget.

Deadlock already uses matchmaking to enforce standards of conduct. Valve's September 12, 2024 update introduced a low-priority queue and penalties affecting chat, matchmaking, and even a player's ability to file reports. Its September 26 anti-cheat update introduced cheating bans, complete with the famously ridiculous option of turning the offender into a frog. These are visible consequences. The calculations behind them are another matter.

Valve has good reasons not to publish its entire behavioral model. In Counter-Strike's Trust Factor FAQ, the company explicitly refuses to disclose the factors in its matchmaking score. Telling every abusive player exactly where the thresholds lie would let them optimize for looking trustworthy. As with a recommendation algorithm, people do not need to know the precise scoring function for it to shape the environment they encounter.

We have already seen why behavior-based enforcement requires care. In October 2023, Counter-Strike 2 players demonstrated that rapidly spinning a mouse at extreme DPI settings could trigger VAC bans, apparently because their movement resembled a spinbot. PC Gamer documented the reports. Players suspected automated behavioral detection, but Valve did not establish the specific mechanism publicly. Publishing every detector would help adversaries; leaving false positives uncorrected would harm innocent players. Secrecy about the model and accountability for its mistakes can coexist.

Some Deadlock players report encountering more cheaters in low-priority matches, while others report cheating in ordinary games. These are experiences, not controlled measurements of cheating rates. They do show why nobody should expect the public matchmaking rules to reveal everything about how risk is assessed.

And that is the more interesting idea: rather than demanding unrestricted authority over every player's machine, Valve can use the service it actually controls to separate disruptive behavior and make fair matches more likely. The details of the model are a legitimate secret. The quality of the experience it produces is what players should judge.

The fight shouldn't be against the personal computer

A multiplayer service can set rules. Nobody has a right to ruin other people's competitive matches. Servers should reject impossible actions, withhold unnecessary information, analyze suspicious behavior, and ban accounts when evidence supports it.

But the PC's appeal has always been that it is your machine. You can debug it, mod it, inspect it, replace its operating system, and decide which software you trust. Cheat Engine is one expression of that freedom. So are custom drivers, virtual machines, accessibility modifications, and the Deadlock skin somebody made for the sheer pleasure of doing it.

Some uses of that freedom violate the rules of a particular game. That justifies consequences inside the game service. It does not automatically justify the endless expansion of a publisher's authority over everything else on the machine.

Valve's approach isn't proven superior. Trust-based matchmaking can fail, cheaters can adapt, and opaque behavioral scores can punish innocent people. Kernel anti-cheat can substantially reduce certain attacks. There is no cheap, universal solution.

Yet the endpoint arms race has a predictable trajectory: the anti-cheat demands more privilege, the attacker moves lower, and the publisher asks the computer for more proof of obedience. Eventually Windows security, firmware, and hardware identity become eligibility checks for playing a video game.

A service that sorts people intelligently, constrains what its servers will accept, and preserves room for harmless client modification may offer a less destructive equilibrium.

The goal should be to protect fair competition—not to win a war against the player's right to own their computer.


Sources and technical reading