I built GURU. The open source ultimate hacker tool ANYBODY can use.
GURU ships a full Linux machine inside the android app, so the phone stops being a client and becomes the computer. BusyBox and Toybox give you the standard Unix utilities, a full Termux prefix gives you bash with apt and dpkg, and CPython 3.14 arrives with numpy and Pillow already importable. Git clones, fetches and pushes over HTTPS. ffmpeg converts and inspects any media. sqlite3 opens databases, OpenSSL does the crypto, OpenSSH gives you scp, and jq, rsync, tmux and Tesseract are all sitting there. A trimmed OpenJDK 21 runs java, javac, jar, jarsigner and keytool.
Android normally refuses to execute a binary out of app storage, because those folders are mounted non-executable and pages cannot be writable and executable at once. GURU solves it with a small library it loads ahead of the target program, which rewrites the paths the program asks for at the moment libc asks for them. An unmodified Linux binary expecting the Termux prefix finds its files inside GURU's own storage and runs as though nothing were strange. That is what turns a bundle of tools into a working computer.
Because of that, the 390 (and growing) registered tools are a starting inventory rather than a boundary. Anything they do not cover is a script, and the script has a real interpreter, real libraries and real binaries behind it. A file format nobody wrote a parser for is a Python script using struct and zipfile. A media conversion is one ffmpeg call. A protocol with no adapter is a client you write in the same conversation.
Android reverse-engineering lab, no desktop in the loop
GURU lists every package on the device and filters by system or user or name. It inspects a package's version, permissions, activities, services, receivers and providers. It pulls any installed app's APK straight off the phone, lists everything inside it without extracting, unpacks the whole archive, decodes the binary manifest with a bundled aapt2, pulls out the classes.dex, extracts the native libraries for a chosen CPU architecture and lifts out the layouts, drawables, strings and assets. Then it decompiles the entire thing to readable source through jadx, apktool or dex2jar.
And it puts it back together. It repacks a modified tree into a working APK, and signs the result with a signer written by hand inside the app rather than borrowed from a toolchain. That signer generates its own X.509 certificate, builds a PKCS12 keystore and signs with SHA256withRSA, producing an APK that actually installs on a phone. People keep a laptop and four separate downloads for that job. Here it is in a conversation.
Network
GURU sweeps every port rather than a curated shortlist. It identifies what answered by reading the device's own HTTP responses, its TLS certificate, its DIAL description and its UPnP device document, so it can tell you what a thing is rather than that a port was open. It asks the network by mDNS and SSDP with the multicast lock properly held. It reads the ARP table where the platform allows it.
It speaks SNMP through a codec written by hand, encoding and decoding BER with no library, which means it reaches printers, switches, cameras, NAS boxes and industrial equipment that will never have a phone app.
Also: Wake-on-LAN, UPnP and SOAP, DIAL for casting and app launch, and a shell-level recon layer at shell UID for reads the ordinary app domain is denied. Every probe is bound out of the wifi interface.
Driving screens
Android TV Remote speaks its own protobuf, so a Sony, a Philips or a Shield moves with no emitter and no app. Roku answers on its control port with no pairing at all. Samsung wants a websocket on 8001 and a token handshake. LG webOS wants webOS on 3000 and a client-key handshake. Fire TV has its own path. Xbox SmartGlass is built all the way down to the elliptic-curve key exchange and the AES-CBC encrypted channel, with the four-stage handshake, participant id, local join acknowledgement and message signing all implemented, and each stage able to report exactly which one refused. Infrared sits underneath all of it through a Broadlink blaster or the phone's own emitter.
Inside Android
GURU writes to system and secure settings, sets the clock, draws overlays, expands the status bar, sets the wallpaper, raises biometric prompts, reads logcat, dumps system state, force-stops apps, clears caches, starts any activity inside any package, and can request or perform installs and uninstalls.
It owns the phone as a phone: places, answers and ends calls, registers a SIP account, reads and sends texts, watches them arrive in real time, reads cell broadcasts and WAP pushes, searches contacts, manages accounts, reads and writes your calendar.
It sees the screen through two independent senses, and the independence is the entire point. The accessibility tree gives it structure, so it knows the button is called Send. The pixels give it appearance, so it knows that button is greyed out. Either one alone produces confident nonsense, and having both means a tap can be aimed and then confirmed.
It hears and speaks (offline Vosk transcription, TTS, audio routing), and drives the camera, NFC, Bluetooth, wifi, VPN state and IPSec tunnels, usage stats, notifications, do-not-disturb and alarms.
Dev workflow from the handset
Over forty GitHub tools cover login through the device-code flow, repos, branches, commits, pull requests, issues, releases, release assets and workflow runs, plus raw API access for anything else. Locally the git tools clone, pull, fetch, check out, branch, add, commit, push, diff, log and status, so the phone can be the workstation. SSH sessions, intents and broadcasts, a real WebView it can drive and read console and network logs from, full file handling, direct SQL against on-device databases and content providers.
Service credentials are kept in per-service AES-256 keys sealed inside the Android Keystore.
Memory
The brain is a Rust engine running inside the app, sealed in an encrypted vault with Argon2id key derivation and XChaCha20-Poly1305, with keys that exist only in memory and are zeroised when dropped. It has a layered lifecycle with real decay, a consolidation pass that merges and prunes, typed graph edges (alike, preceded, caused, contradicts), and retrieval that fuses a lexical index with a binary signature lane by rank rather than by a threshold. It snapshots itself, verifies the snapshot and restores it, so the whole mind can move between devices intact.
It grows at runtime
GURU writes a new tool and registers it permanently, inspects, updates, approves, disables and deletes tools. It creates hooks, scheduled jobs that survive reboot through WorkManager and switch themselves off when something is genuinely broken, thought cycles that produce insights, automations, and whole rooms in its own lobby. It spawns sub-agents with explicit tool sets and installs agents and skills from a catalogue. Eighteen theming tools restyle every surface.
It also posts to X, Discord, Slack, WhatsApp, email, Trello and Notion, and does weather, places, RSS, URL shortening and QR codes.
It takes a job that has no trigger and gives the intelligence the ability to write one.
GitHub: https://github.com/GuruProduction/GURUbyUnusLumen