Damru
How Damru works
Damru layers four open technologies into one pipeline: Redroid → native Android hooks → Chrome DevTools Protocol → Playwright.
Instead of patching a desktop browser with JavaScript (the approach detectors have learned to read), Damru runs a real Android device and changes the fingerprint below the browser, at the operating-system and binary level.
The stack, layer by layer
1. Redroid (real Android). Android 14 runs inside a Docker container — a genuine device stack, not an emulator skin over desktop Chromium.
2. Native OS hooks. C/C++ hooks (LD_PRELOAD), resetprop and iptables modify device identity, system properties, and network at the OS level.
3. GPU + hardware layer. Vulkan/GLES binaries are patched and CPU/RAM/touch values overridden so the hardware fingerprint is internally consistent.
4. Chrome DevTools Protocol. Chrome is driven over CDP via ADB — no JavaScript injection into the page.
5. Playwright API. You script it all with a familiar Playwright-style Python API (AsyncDamru / Damru).
What changes at each layer, and why is it undetectable?
Each layer changes one part of the fingerprint using a different open technology, and every change happens below page context — so there is no injected script for a detector to read.
This entity-attribute table maps each layer to the technology behind it, what it changes, and why the change stays invisible to detection.
| Layer | Technology | What it changes | Why undetectable |
|---|---|---|---|
| Real device OS | Redroid (Android 14 in Docker) | Runs a genuine Android stack instead of desktop Chromium | The OS itself is Android — nothing is emulated for a detector to expose |
| Device identity | resetprop / system properties | Model, brand, build, and system props of the device | Values are set at the property layer, below any page script |
| Network | iptables / LD_PRELOAD hooks | TLS / JA3 signature, routing, and leak prevention | The handshake happens at the network layer, not in JavaScript |
| GPU & hardware | Patched Vulkan / GLES binaries | Renderer strings, CPU cores, RAM, touch points | Binaries are patched on disk, so the values are real to the system |
| Browser control | Chrome DevTools Protocol via ADB | Drives the browser and reads the page | CDP attaches externally — nothing is injected into page context |
How do I observe and control my workers?
Damru gives you a local dashboard (Damru UI) to start, stop, and inspect workers, and a live viewer (Damru View) to watch or drive any running instance in real time.
The pipeline above produces and runs the instances; an operational layer sits on top of it. The local Damru UI dashboard binds to 127.0.0.1 and exposes panels for setup, worker control, a Work Lab, and logs. Damru View streams a live scrcpy view of any worker, with a --no-control watch-only mode that is safe to leave open during an automation run. Together they are the developer equivalent of a GUI instance manager — kept in code. Read the full browser instance manager guide, or browse the device profiles the pipeline applies.
Why this beats JavaScript-based stealth
JavaScript-hook tools (undetected-chromedriver, playwright-stealth) leave an injected surface in page context. Damru has nothing in the DOM to detect because the spoofing already happened at the OS/binary/network layers before the page loads. See the playwright-stealth comparison and the benchmark results.
FAQ
Why use Redroid instead of an Android emulator?
Redroid runs a real Android 14 OS inside a Docker container, so the device stack is genuine rather than an emulator skin over desktop Chromium. Emulators expose tell-tale artifacts that detectors read; a real Android OS does not have them to expose.
Does the Chrome DevTools Protocol inject anything into the page?
No. CDP attaches to Chrome externally over ADB to drive the browser and read the page — it does not inject JavaScript into page context. That is why there is no script surface for a detector to find.
Can I watch and control a running worker?
Yes. Damru View streams a live scrcpy view of any worker so you can watch automation in real time or take manual control, and the local Damru UI dashboard lets you start, stop, and inspect workers. See the instance manager page.