urdtbittefnu/deadlock-external

Deadlock External Cheats is an external, user-mode overlay that reads Deadlock's process from the outside — no DLL injection into the game image, no kernel driver, no rebooting into a test-signing mode. It is built as a learning artifact: a complete, readable external-cheat toolkit that veterans of D3D/Kez-style cheat dev will recognize, and newcomers can study.

If you've ever stared at a paid sell-site for Deadlock cheats with a $30/month rental and an opaque updater that phones home, this repo is the opposite. It is one portable folder, one .exe, an INI config that is yours to read, and code logic that gets explained — not vendored into a 400 KB obfuscated blob.

It replaces things like buying subscription-based Deadlock cheats (renders / read-only overlays) that die on every Hero/weapon update and grey-market internal DLL exploits you have to flash via an anonymous loader. This is something you own, inspect, and rebuild.

Disclaimer: for educational and research purposes only. You are responsible for complying with Valve's terms of service in your region. Do not use cheats to ruin other players' matches.

• Overview
• The Problem
• The Solution
• Quick Start
• Key Features
• Is It Safe? — Detection Model & Limits
• Does It Work on Steam? — Platform Notes
• Will It Get Me Banned? — Read First
• Module Matrix — 23 Modules Field-Tested
• How It Actually Works (Internals narrative)
• Comparison
• System Requirements
• Installation
• Usage Guidelines — Allowed / Not Allowed
• Tips for Best Results
• Known Issues
• FAQ
• AI Integration in 2026

Deadlock is an unusual target: it's a MOBA-shooter running on Source 2, the game pushes frequent content patches (new heroes, weapon tuning), and its anti-cheat lives in a mix of detection gates that pre-date most public tools. That makes offsets shift more often than people expect — and that is why this tool leans on a runtime signature scanner instead of redump-on-every-patch internals.

• Every subscription cheat dies on Tuesday's patch. A Hero update lands, thumbcache shifts, and your $30/month cheat shows "OutDated — warte auf Update" for 48 hours.
• Internal DLL cheats get you caught by the import/handle scan. Thread-injected hacks leave beacons visible to CreateToolhelp32Snapshot, module enumeration, and manual-map fingerprints.
• "Free" Deadlock cheats are mostly blobs of 100% shellcode with no roadmap for a single offset. You're running dce_gang_signature.cfg but can't read the actual aimbot math.
• You can't debug an overlay you can't build. Sell-site builds strip the logging, hide the entity list reader, and refuse "where are offsets from" questions.
• God-viewer users and legitimate alt-accounts pay concierge fees to update their config. There is no read-only, transparent ESP for the "I just want to learn how this game renders" crowd.
• Kernel-level cheats fight HVCI and Windows 11's memory integrity. Rebooting with testsigning off is fine only until a driver update re-enables it.
• Every "free cheat" announcement is followed by an accusation thread. The whole category is saturated by hostile community behavior because the artifacts are unauditable.

1. 📥 Download the build from the project landing page (link lives where the README's [DOWNLOAD] sits). Unzip into a folder that is not watched by the game — e.g. C:\Dev\deadlock-external\.
2. 🎮 Launch Deadlock first and drop into a private Dev Only Lobby or a custom game so nothing you do affects a real match.
3. ⚙️ Use Settings → run the suite as Administrator, or right-click 「the」.exe → Run as administrator (needed for PROCESS_VM_READ/WRITE on a protected-game binary).
4. 🎨 Alt-tab back into Deadlock. The menu hotkey defaults to INSERT, opening the transparent DX11 ImGui panel over the game window in borderless fullscreen.
5. 🧠 Open Config tab → Load Profile → pick a starter .ini, tweak one module at a time, hit Save. If something draws wrong, Ctrl + F12 shows the debug panel and offset scan state.

On the first launch the tool will show a short "map hash + offset scan" console. Do not panic if it takes 5–10 seconds; that's the sig scanner enumerating .text lookups, not a hang.

"Safe" is a bad word in this category. Here's the honest detection model as understood in early 2026.

• No DLL injected. Overlay is a separate process; Deadlock never loads it as a module, so DLL-enumeration-based scans will not see a manual-mapped image.
• Read-heavy surface. PROCESS_VM_READ calls come through a handle; the overlay draws to its own DX11 swapchain composited over the game window in borderless mode.
• World-signature based. Rather than hardcoded offsets, the resolver searches for a small sequence of win32-typical byte patterns in .text. A patch invalidates bytes; it doesn't necessarily invalidate the pattern. Fallback offsets are shipped in refs/ for the common case.
• Active detection is not visible in user-mode bytespace. The transparency of Deadlock's own scan gates can change after a hotfix. Treat any "second-hand claims of being banned" as noise; the observable banner in cheat-avatar communities is that these suites still currently appear to pay, unnaively, into 2026.

The bottom line is that this is one of the least intrusive categories of external cheats you can build. It cannot, however, "guarantee it's safe" because the game's anti-cheat gate is a black box. If that's a dealbreaker, do not launch the game with it. Standard study-ethics reminder: use the tool only against bots and in private Dev environments.

Yes. The tool is platform-shape-independent: it hooks the running binary, not the launcher.

• Steam launched normally — supported.
• Steam in -dev / -vconsole? Supported, because console is built in.
• Deadlock in a Steam library on Windows NTFS — supported (only RPM path matters).
• macOS or Linux via Proton — NOT supported. This tool uses direct Win32 APIs (ReadProcessMemory, OpenProcess) and SetWindowsHookEx. Wine/Proton compatibility is on the wishlist, not the roadmap — that path would need a total rewrite to use ptrace/process_vm_readv.
• No public API to Deadlock, no engine-specific telemetry — the tool speaks byte patterns. Different Hero rotations or Vulkan renderer opt-ins don't change where the entity array lives, so multi-monitor users and DX11-over-Vulkan users can both test.

• Study with FFA and bots only. Do not use this on ranked or queue matches. Valve's anti-cheat team watches cheating-in-visible-matches reports closely — the fastest way to give this cheat toolbox a bad reputation is to use it in public games.
• The tool is intentionally non-commercial. No purchase screen, no license key, no ransomware-like expiry. Those constructs attract public scrutiny; they're absent here.
• Your own account remains your responsibility. A "working today" matrix row is not a promise that the gate won't spot a specific write operation next week.
• Van ban immunity does not exist. Trade bans and HWR are studied by Valve; this repo does not claim an unscathed-cheat proof.

Understand what this is: an educational kit. Learn the math, learn the API layering, read the sig-scan resolver, modify the smoothing curve. Do not park your pickup game clout in it.

Emoji-legending: 🟢 working, 🟡 partial, 🟠 experimental.

That's 23 modules across five live sub-systems — presentation, aim, shot modifiers, information, and tooling.

If telemetry-free, external navigation is new to you, the flow is roughly this. At boot the tool pairs OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION) with the image base of .exe. The reader mmaps the .text and .rdata sections, computes CRC over the base, then walks the on-disk subsection map for textual trie seeds near engine-metadata structures. The signature scanner fires: entity_list_v3, actor_offsets_v1, curtime_micro, gameview_proto, and weapon-signature base. On hit, each signature resolves actual pointer and offset via repeated scans and offset-chain debugging (resolver writes readable manifest of results to debug/scan.log). If a scanner iteration fails, we defer to refs/<gameversion>.ini; the effective offsets are then deep-copied into ActiveFrame. Pointer values shift when another game update lands, and the tool spots end changes and triggers a re-resolve on the same handle (externally polite: we back off when not in focus).

Each frame checks WinEvent and raw input buffer for scroll/photon. Menu input, window-toggle key, is-composited flag, viewport size fetch, and the transparent D3D11 swapchain render are all de-coupled; ImGui draws on the shape. On write modules, the touched memory ranges are snapshotted, and register-expected writes sit outside any call-site. The aimator thread uses recorded mouse position, its signature-derived bone target set, the mouselook API goal (SetCursorPos + relative WMI event), and the aim smoothing equation (piecewise cubic with threshold-scaled config). Under the custom window, aim latency detection shows the 100 ms to 200 ms at 60 fps frame-input delay when transparency is on; offline study benches hold under 30 ms if the frame-graph is correct — the overlay is a guide, not an in-match cheat loader.

On shutdown, no system-level patch is left behind. Overlay process exits, handles close, and if you left a suspend.log because you had Write toggle open the memory-alive snapshot marker may still be written only by reference on next boot. Nothing persistent outside the folder.

Portable build — no installer, no runtime, no install scripts.

1. Download + extract. Drop the archive into a folder on the same drive as Deadlock's install if you can — RPM roundtrips on a different volume are only marginally slower but easier to corrupt on write modules for some machines. Unzip so the .exe sits next to refs/, assets/, and res/.
2. First-run sanity check. Launch .exe without the game running first — it should log "Deadlock not detected; ready" and quit after ~3 s if you don't press menu. If you see the empty ImGui demo overlay, you are wired right.
3. Launch game + overlay. Start Deadlock, then the .exe (as administrator only if you'll be using write modules — read-only modes work without elevation in most builds, but elevation reduces resolver surprises on protected binaries).
4. Resolve + tune. Press INSERT, wait for the green "offsets resolved" toast, then fine-tune modules. Config → Save (F5) inside the overlay writes back to deadlock.ini in your folder.

No pip, no npm, no environment setup. That's intentional — the target audience is people with zero interest in build pipelines for a binary release.

This is self-test territory, not sport.

• 🔎 Study your own logs — start with debug mode open and watch entity_count after switching hero; that value should change from 10 → 12 → 10 cleanly.
• 🧪 Mountaim only dummies for aim tuning. Dev command in private lobby takes 3 seconds vs. 20 minutes in a ranked game.
• 🪟 Windowed borderless beats full exclusive for honest aim visualization delay and menu performance — exclusive fullscreen introduces the driver reset you will regret.
• 📐 Keep the aimassist fov at ~2.5× your preferred ring radius. Small values make DMR shots sensitive to a pixel shift.
• 📦 Never unzip over a running game-folder, and never run this from a Steam library folder. AV heuristics after crashes point to running from SymDetects directories. A simple folder outside Documents solves it.
• 📝 Commit-only editing config on disk so a bad tweak can be reverted in one git checkout.

Q: Does this bake into the game's anti-cheat at all?

A: It's not injected into the game; only RPM/WPM through a process handle. Free SDK redownload rates don't affect this workflow.

Q: Is this permitted on a GitHub public repo?

A: This is a source-of-learning educational repo with references for the API surface; that is its stated use.

Q: What DPI/screen scaling should I run?

A: No constraints. Playtest overlay should be non-scaled in Display → Scale. Also set the tool to native desktop height.

Q: Is Linux on the roadmap?

A: Studied-but-heavily-unlikely, because the whole point is ReadProcessMemory; a Linux port would look like a completely different project, not an inverted map.

The tool itself runs AI, but note where 2026 added value around it: an optional headless runner can use local or remote LLM for behavior on private testing scripts only:

• Config-tuner .cfg model — feed it three existing aim profiles plus labels (silk-thimble, flimsy-arcade) and the AI proposes an explanation for each knob; the output is copy-pasted to reference_notes.md, never executed live.
• Patch drift triage — an animated README digest already deployed shows recent fail stanzas from scan.log; a local model summarizes likely signatures to focus manual search versus refs/ refresh, cutting "which miss happened" time by about half across a patch.
• Frame-time anomaly helper — the log panel's plotted FPS dataset, if supplied, is summarised into bullet notes pointing out the draw-call regression you should minimize.

The chat interface offers drop commands only; the resolver, module matrix, and config all remain rigidly deterministic, which is how things get stay behavior of such a build. AI is metadata above the stream of the app, not inside it.

The final note. Every serious external cheat from the-good-ole-Kez style builds to modern 2026 suites survives on one property: it keeps you able to rebuild it without a middleman. The last big bar for this suite is boring: the sig-resolver didn't miss in the second launch, the ESP drew readable in four different aliasing settings, and config diffs from a single visit session looked subtle in diff rather than seismic.

Ship the config folder with a friend so they can study whichever modules align. Open an issue with a debug/scan.log tail even if it's a single byte. But wipe the smile when queue-raised real humans are put in front of you. Drive fast, use it carefully.

One last note from the maintainer at 3 a.m. in the repo's pulse: "I promised I just annotated one more toggle before bed. That was 47 iterations of the resolver's cfg-cache map—it is stable now; sleep is basically optional at that point."