v0.1.1 — PortProton/Lutris/Heroic support + deferred-list catch-up

Patch release with a stack of features and fixes since v0.1.0. Most relevant fix for users on this release: PortProton / Lutris / Heroic / Bottles Wine-wrapped games now show up in the Open Process dialog (#2).

Fixes

• PortProton / Lutris / Heroic / Bottles compatibility (#2) — process enumerator now picks up Wine-wrapped games regardless of what their /proc/<pid>/comm reads. Filter and tooltip prefer the recognisable .exe name from cmdline.
• CI hardening — DWARF code path now compiles cleanly with libdw-dev (was missing <dwarf.h> include).

New features since v0.1.0

Auto-assembler

• {$if}/{$else}/{$endif} preprocessor conditionals
• @@: anonymous labels with @F / @B references
• globalalloc() (shared symbol across scripts) and break (fail-loud directive)
• {$ccode}…{$endccode} blocks compiled inline via libtcc (when libtcc-dev is installed)

Debugger

• LBR (Last Branch Record) tracer via perf_event_open + Branch Mapper window
• Intel PT raw-capture wrapper
• Follow fork / vfork / clone / exec in LinuxDebugger (foundation for multi-process)
• ARM64 + ARM32 CONTEXT marshalling in RemoteDebugger
• ceserver CMD_GETSYMBOLLISTFROMFILE for remote symbol fetch
• In-process VEH shim (LD_PRELOAD library, equivalent of CE's VEHDebugger)

Analysis & symbols

• Find-statics analysis pass
• DWARF function-name lookup wired into the disassembler pane (when libdw-dev is present)

GUI

• Form Designer — visual builder for Lua trainer UIs (palette / canvas / properties / JSON save+load / live Lua codegen)
• File Patcher dialog
• ELF Inspector window (binutils-backed)
• Snapshot/freezer engine + Tools menu UI (capture / diff / restore / save / load)
• Process Watcher → auto-attach by name from Tools menu

Lua surface

• Stream (memory + file) and StringList userdata — TMemoryStream / TFileStream / TStringList equivalents
• setProcessName / getProcessName bindings (process-name camouflage)
• Auto-Assembler script templates menu (Allocate / Code injection / AOB injection / Full / Pointer / Cheat-table framework / {$lua} demo)

Scoped process-name camouflage (new in this release; documented limits)

• User-space prctl(PR_SET_NAME) Lua binding
• Optional kernel-side /proc/<pid> filtering via cecore_kmod (CAP_SYS_ADMIN, up to 32 PIDs)
• Use case: hiding cecore from single-player anti-tamper string scans. Does not defeat multiplayer anti-cheat (EAC/BattlEye/Vanguard etc.) — those run their own kernel modules and detect rootkit-style hooks. Documented at README level.

Speedhack

• Now covers clock_nanosleep, usleep, sleep, select, poll, SDL_GetTicks, SDL_Delay (previously only clock_gettime / gettimeofday / nanosleep)

Network / remote

• Mono soft-debugger client (TCP handshake + VM/Version + generic packet send)

i18n

• Locale detection + QTranslator scaffolding (drop cheatengine_<locale>.qm into translations/)

Optional GPU acceleration

• CudaSearch foundation — GPU-accelerated buffer scan for 64-bit pointer values, gated behind find_package(CUDAToolkit). Stubs cleanly when CUDA isn't installed.

Build

git clone https://github.com/ts-solidarity/cheat-engine-linux
cd cheat-engine-linux
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)

Or download the CheatEngine-x86_64.AppImage asset below — drop-in executable, no install needed.

Optional system packages that unlock additional features at configure time:

• libdw-dev — DWARF source-line + function-name annotations in disasm
• libtcc-dev — inline {$ccode} blocks in AA
• nvidia-cuda-toolkit — GPU-accelerated buffer search

v0.1.0 — first tagged release

First tagged release of cecore — Linux-native C++23/Qt6 reimplementation of Cheat Engine.

This is an early release of an actively-iterating project. The build is green on Ubuntu 24.04, the regression suite passes, and the surface below is exercised end-to-end via tests or interactive use. Expect rough edges; please file issues.

What's in it

Memory scanning

• Numeric (Byte/Int16/Int32/Int64/Float/Double), string (UTF-8/Unicode/codepage via iconv), AOB with ?? wildcards, binary with bitmask, all-types-at-once, grouped, custom Lua-formula
• Compare ops: exact / greater / less / between / changed / unchanged / increased / decreased / unknown / same-as-first / percentage
• Float rounding modes (exact / rounded / truncated / extreme + tolerance)
• Multi-threaded with progress + cancellation; disk-backed result buffers

Pointer scanning

• Reverse-BFS path discovery with depth/offset/alignment/static-only filters
• Distributed sharding for parallel workers
• Save/load result sets, sort by depth/offset/module, merge with dedup, rescan against a new runtime target

Debugger (local + remote)

• ptrace attach, software int3 + hardware DR0–3 breakpoints (read/write/access, configurable size)
• Conditional Lua-evaluated breakpoints, one-shot, thread-filtered
• Single-step (Into/Over/Out), break-and-trace
• Stack trace via frame-pointer walk, signal-based exception breakpoints
• GDB remote protocol client
• Remote ceserver target support via RemoteProcessHandle + RemoteDebugger — same APIs as local; full memory R/W, region introspection, modules, threads, breakpoints, debug events, x86_64 register get/set

Auto-assembler

• alloc (with ±2GB near-allocation), dealloc, labels with multi-pass forward-resolution
• aobscan / aobscanmodule / aobscanregion / aobscanall
• db/dw/dd/dq/ds, nop, fillmem, assert, fullaccess, readmem, reassemble
• loadbinary, loadlibrary (ptrace+dlopen), createthread, createthreadandwait
• include, struct/endstruct with field offsets, {$try}/{$except}/{$endtry}
• {$lua}…{$asm} blocks evaluated at preprocess time; result spliced back into the AA stream
• Plugin-extensible custom commands; preprocessor and postprocessor hooks

Code analysis

• Module dissect (call-target function discovery, call graph)
• Referenced strings, RIP-relative scan, code-cave detection, assembly-pattern scan
• Find-what-accesses / find-what-writes with per-hit register snapshots

Cheat tables

• CE-compatible .CT XML save/load (textual types: "4 Bytes", "Float", "Array of byte"…)
• .CETRAINER password-wrapped payload
• Embedded enable/disable AA scripts and Lua scripts (table-level + per-entry)
• Structure definitions persisted (XML + JSON round-trip)
• Standalone trainer generator (terminal UI)

Lua scripting (Lua 5.3)

• Memory R/W (typed + local variants), AOBScan, assemble / disassemble / autoAssemble
• Process / module / thread enumeration, symbol register/lookup
• MemoryRecord and AddressList userdata with property syntax (mr.Address, mr.Value, mr.Active, OnActivate event slot)
• GUI components: createForm, createButton, createEdit, createCheckBox, createLabel, createMemo, createPanel, createGroupBox, createListView, createTimer, getMainForm
• Hotkeys, threads, custom value types, structures
• {$lua} AA-block bridge

GUI (Qt6)

• Main window with process selection, scan controls inline, address-list grid, freeze timer
• Memory browser: hex pane + disassembler pane (split), symbol-resolved annotations, RIP-relative resolution, DWARF source-line annotations (when libdw-dev installed)
• Disasm pane: selection, right-click menu (copy address/bytes, follow operand, set/remove SW or HW breakpoint, NOP this instruction, save region), breakpoint glyphs in gutter, double-click follow-jump
• Hex pane: right-click menu, find-what-accesses launcher
• Find-what-accesses results window with per-hit RAX/RBX/RCX/RDX/RIP columns + double-click full register dump
• Tracer window with worker thread, progress bar, register columns, save trace
• Breakpoint list, register editor (incl. floating-point panel via PTRACE_GETREGSET), thread list, stack view
• Memory regions, heap regions, module list, code references
• Settings dialog with six tabs (Scan / Display / Debugger / Memory View / Hotkeys / Network)
• "Connect to ceserver…" for remote targets
• Lua console
• Catppuccin dark theme

Symbols

• ELF .dynsym / .symtab resolver
• module!symbol+offset arithmetic in expressions
• /proc/kallsyms parser
• Optional DWARF line-table reader via libdw (when libdw-dev is present)

Plugin ABI

• Structured C ABI in plugins/cecore_plugin.h — single ce_plugin_entry symbol, CePluginHost callback vtable (log, register Lua function, get attached pid, read/write memory)
• Legacy symbol-based ABI still supported as fallback

Network / remote

• ceserver TCP client implementing 24 of ~40 wire commands: open, close, read/write memory, region query, module + thread enumeration, allocate/free/protect, debug start/stop, wait/continue events, set/remove breakpoints, suspend/resume threads, get/set thread context, speedhack
• RemoteProcessHandle and RemoteDebugger adapters so the rest of the codebase uses remote targets transparently
• zlib network compression helpers
• GDB remote protocol client

Optional kernel helper

• cecore_kmod module exposing CAP_SYS_ADMIN-gated ioctls for privileged target VM access, physical-memory read/write via ioremap, virtual→physical translation
• Process hiding intentionally not implemented

Speedhack

• LD_PRELOAD intercept of clock_gettime, gettimeofday, nanosleep
• Live multiplier via shared memory /ce_speedhack

Vulkan overlay

• Explicit Vulkan loader layer + JSON manifest helpers
• X11 click-through transparent OSD overlay for FPS / status / crosshair

Quality

• ~28K lines across ~120 source files
• Build: cmake -B build && cmake --build build (FetchContent handles missing Capstone/Keystone)
• Headless regression suite (cecore_test) covers ~80 sub-asserts
• CI on every push (Ubuntu 24.04, full build, full test, smoke-launches cescan, attempts kernel-module build)

Known limits

• One planned feature is intentionally out of scope: kernel process hiding. This project doesn't ship rootkit-style stealth.
• DWARF support requires libdw-dev at configure time; without it the relevant code path stubs out (no source-line annotations).
• ARM/ARM64 architectures: backend exists, not exercised in the regression suite.
• Form designer (visual builder for Lua trainer UIs) is not yet implemented.
• ceserver client covers memory/debug/threads but getThreadContext/setThreadContext is x86_64-only for now.

Build

cd cecore
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)
sudo LD_LIBRARY_PATH=build build/cheatengine

Lua sources are still expected at ../Cheat Engine/lua53/lua53/src (the upstream Pascal CE checkout) by default; override with -DLUA_DIR=/path/to/lua-5.3/src.

Thanks to @Twig6943 for prompting the build polish that made this release possible (#1).