Quote:
Originally Posted by jiaqi
Thank you boss i appreciate it and yes my goal is to one day may a good product to sell later later on once i know everything and can do everything with ease. Thank you once agian
|
Hey man. I was closing tabs and saw this one still open, and I wanted to add one more thing. What I said earlier was pretty vague, and I prefer finishing my thoughts instead of leaving them hanging. I’m also a pretty opinionated and sometimes arrogant person, so I just want to share my perspective. After that, you can decide your own roadmap and choose what works best for your learning path. This is simply what I’d recommend.
Your mindset NEEDS TO BE Ignore “Cheats” at the Beginning
Don’t worry about cheats at all. Don’t even think about the word. Instead, focus on learning the operating system itself and separate anything related to cheats from your thinking for now. Treat it like a proper computer science course.
Focus on things like:
• Memory management
• Drivers
• Windows internal API calls
• Security functions
• General computer science fundamentals
I didn’t approach it this way when I started, but I wish I had. It would have made the learning process much easier and more structured.
I went straight into C++, but then I found myself stuck. I knew C++, but I was sitting there thinking:
How do I know what the anti-cheat is doing?
How do I find a bypass?
How do I decrypt certain memory regions?
How do I make a driver?
How do I even load and map the driver?
How do I make the driver undetected?
That’s where assembly and deeper system knowledge come in. I wish I had started there first, because skipping that step and jumping straight into C++ makes everything extremely confusing.
Learning Operating System Fundamentals
After deciding to learn the OS properly, spend serious time on it. This will take a while, so don’t just watch random YouTube videos. Actually buy a book and study consistently for several months.
Spend around six months learning the fundamentals so you truly understand what’s happening behind the scenes.
Once you have a solid grasp of:
• Memory
• Processes
• System calls
• Kernel vs usermode
• Windows internals
you’ll be in a much better position to understand everything that comes later.
Learning Cheat Engine (Understanding Memory)
After learning the OS fundamentals, you can move toward the practical side using Cheat Engine.
Use it on a random game and explore it extensively. The goal here isn’t to make cheats it’s to understand what you’re actually looking at.
A lot of people jump straight into cheat development without understanding the underlying concepts. Even some experienced people in the scene struggle to explain the backend of what they’re doing.
Spend time learning:
• What values represent in memory
• Pointer scanning
• Structure dissection
• What instructions modify values
• How memory changes during gameplay
This stage builds intuition about how programs behave in memory.
Learning C and Basic Assembly
Before moving into reversing tools, you should know:
• C programming
• Basic assembly
You’ll usually pick up the fundamentals of assembly naturally while studying computer science and operating system internals.
You don’t need to be an assembly expert, but you should at least be able to read and understand basic instructions.
Learning IDA64 (Interface and Tooling)
After that, download IDA64 and focus on learning the interface and tooling first.
This part is extremely important. There’s no point starting serious reverse engineering if you don’t understand the tools you’re using.
Learn things like:
• What different windows and views do
• Navigation shortcuts
• What Ctrl+C, Ctrl+F12, etc. actually do
• How cross-references work
• How functions and structures are represented
Basically, learn everything about the tool itself before trying to reverse complex programs. You need to fully utilize the entire tool suite available to you.
Practicing on Simple Games (AssaultCube)
Once you’re comfortable with the interface, download a simple game like AssaultCube.
Start exploring things that interest you, such as:
• Player position
• Health values
• Other gameplay structures
Try to rely less on Cheat Engine and more on reversing tools like IDA64 and plugins. Modern games often detect Cheat Engine immediately, so learning to work without relying on it is important.
The goal here is simply learning how to locate values and understand game structures.
Moving to Unity Games
After getting comfortable with basic reversing, move to Unity games.
Unity is a good place to start because:
• Many games have weak or no anti-cheat
• Code is often easier to analyze
• Systems like Mono make things easier to inspect
Technically this is usually obfuscation rather than true encryption, but it still teaches you how developers hide values and structures.
You’ll also start encountering things like:
• Metadata protection
• Encrypted structures
• Blocked memory regions
This gives you exposure to real-world techniques used to hide game data.
Learning About Encryption and Protection
At this stage, spend time studying different encryption or protection techniques.
For example, if you hear about something like CR3-based protections, don’t jump into something like Valorant and try to reverse it. Instead, research the concept itself.
Understand:
• What the protection does
• Why it exists
• How it works internally
The goal is simply knowledge, not bypassing anything specific.
Building Your First Cheat (No Anti-Cheat)
After roughly 6+ months of learning, try building something simple for a game that does not have anti-cheat.
By now you should have a basic understanding of:
• Reversing
• Memory structures
• C++
• Basic assembly
Create a simple project and see what’s possible. During this stage you’ll learn a lot through experimentation.
You’ll also start realizing that sometimes things aren’t named clearly, or values are stored in unusual ways. Learning how to figure these things out is part of the process.
Start building things in C++ in usermode first.
Learning Driver Development
Once you’re comfortable with usermode development, move toward driver development.
At this stage you’ll start learning:
• How drivers are loaded
• What driver mapping is
• What happens behind the scenes during driver loading
There are tools like kdmapper, but personally I believe building things yourself from scratch teaches you far more.
This step helps you understand:
• How drivers operate
• How they interact with the kernel
• How they can be loaded safely and hidden
Kernel Communication (Ring0 - Usermode)
After understanding driver loading, the next step is learning communication between:
• Ring0 (kernel space)
• Usermode applications
At this point you’ll typically read memory from kernel space instead of usermode.
This requires building communication systems between your driver and your usermode application.
Reality of Anti-Cheats
Eventually you’ll combine everything you’ve learned into a full project.
This is usually where things become difficult for beginners. You’ll run into anti-cheats and start getting banned frequently.
At this stage you’ll probably need to learn about
:
• Hardware spoofing
• System identifiers
• Detection methods
You can either continue practicing on smaller games or invest serious time learning how these systems work.
My Personal Experience
I’m still learning myself.
My first project was for a Unity game. I spent about three months just finding and building a bypass.
During that time I encountered multiple protection systems, including a kernel-level anti-cheat that monitored memory reads. It could detect when certain addresses were accessed too frequently and flag them.
For example, similar systems to what Valorant uses will flag repeated reads of sensitive memory regions.
I had to figure out ways to:
• Avoid reading certain addresses too frequently
• Decrypt protected memory regions
• Locate signatures for hidden data
• Fix logic errors in my own code that were triggering flags
I also discovered three different encryption layers designed to push you away from the actual values you’re targeting.
Eventually I managed to make it work, but the project only lasted about two months before the developers started patching it.
Because I spent three months building a single bypass only for it to be patched quickly, things became extremely stressful. I had customers waiting on me, and as an honest developer you don’t want to leave customers hanging or risk getting them banned.
A ban wave eventually happened, and it put a lot of pressure on me. I didn’t want to rush another bypass and cause more bans, but at the same time I was getting hundreds of DMs every day.
So I tried hiring external developers to help speed things up. Unfortunately, I got scammed multiple times. One developer disappeared with the money, and another sent rushed, low-quality work.
Yes, it might look bad saying it out loud, but the goal at the time was just to have something basic running while I worked on a proper solution myself.
Eventually I realized that approach wasn’t sustainable. In the end, I had to shut everything down completely and start from scratch.
After that, I rebuilt everything privately and focused on doing things properly. Since then, I haven’t had any major issues.
Right now I make roughly $1200 a month with a very small client base, and I keep things extremely controlled.
Even today I still go back into the game and analyze it further. I keep reversing and studying it until I fully understand it. I won’t move on to the next project unless I’m confident I can completely reverse the game and understand how everything works internally.
What I’m trying to say is: knuckle down and learn everything properly. Don’t skip steps.
You need knowledge of every part of the computer, just like you need knowledge of every part of cheat development. If you only understand one piece of the system, you’ll eventually hit bottlenecks.
It’s the same idea as a physical computer: if one component is weak, the entire system suffers. Development works the same way if your knowledge is limited in one area, it will eventually hold you back.
I’ve been learning for about two years now, and just like you I want to move into more challenging projects.
My goal for this year is to build something for COD, and after that eventually move on to VGK.
More yap
Don’t rush the process. Focus on understanding the system first, not just making something that works. If you skip core knowledge, you’ll eventually hit bottlenecks that stop you from progressing. Learn every layer of the computer properly how the OS works, how memory works, how programs execute, and how protections are implemented.
Treat it like a long-term skill, not something you rush for quick results. The more complete your knowledge is, the easier everything becomes later.
Roadmap (Step-by-Step)
1. Operating System Fundamentals
• Study Windows internals
• Memory management
• Processes and threads
• System calls
• Kernel vs usermode
• Drivers and security functions
2. Programming Foundations
• Learn C
• Learn C++
• Learn basic x86/x64 assembly
• Understand how compiled code translates to assembly
3. Memory Analysis with Cheat Engine
• Practice scanning values
• Pointer scanning
• Structure dissection
• Understanding instructions modifying memory
• Observe how programs behave in memory
4. Reverse Engineering Tools
• Learn IDA64 interface
• Navigation shortcuts
• Cross references
• Function analysis
• Structure reconstruction
• Fully understand the tool before serious reversing
5. Practice on Simple Games
• Start with games like AssaultCube
• Find player position
• Find health values
• Understand game structures
6. Move to Unity Games
• Analyze Mono/IL2CPP structures
• Learn about obfuscation
• Practice locating hidden values
• Understand metadata and structure layouts
7. Study Protection & Encryption Concepts
• Research memory protection techniques
• Learn how data may be hidden or obfuscated
• Understand system concepts like CR3 and memory translation
8. Build a Basic Project (Usermode)
• Create something simple in C++
• Work in usermode first
• Learn how to read program memory and process data structures
9. Driver Development
• Learn Windows driver architecture
• Understand driver loading
• Learn how kernel components interact with the OS
10. Kernel ↔ Usermode Communication
• Build communication between kernel components and user applications
• Understand how data moves between system layers
11. Long-Term Practice
• Continue analyzing software deeply
• Study protection systems and detection methods
• Improve reversing and low-level knowledge over time
You’re not too late.
