EmuLabZip

Inspect, monitor and debug the apps running in your Android emulators and iOS simulators.
A fast, beautiful, open-source developer lab written in Rust.

Install · Features · Getting started · Logs · Performance · Storage · Network · Traces · Crashes · Layout · Sessions · MCP · CLI · Architecture · Roadmap · Contributing

EmuLabZip connects to your running emulators and simulators on its own and brings everything you reach for while debugging into one window: what the device is, what it is logging, how fast your app runs, where its memory goes and what it keeps on disk and what it says to the internet; and then it lets you change that: mock a response, stop a request, record a whole run and compare two devices. It ships as a native desktop app and as a command-line tool, and as an MCP server for AI assistants.

Highlights

• Android and iOS, side by side. Android emulators and devices through a pure-Rust ADB client, iOS simulators through simctl. Switch between them in one click.
• Zero setup. Start an emulator or boot a simulator and it shows up. Nothing is installed on the device.
• Logs that keep up. logcat and the iOS unified log in one virtualized table that stays smooth at thousands of lines per second, with level, tag, text, regex and per-app filters.
• Live performance. CPU, memory, frame rate, janky frames and battery for the app you pick, charted as it runs.
• Find what grew. Memory snapshots with a diff by category, and heap dumps (.hprof) or memory graphs (.memgraph) one click away.
• Look inside the sandbox. Browse an app's files and open SQLite databases, SharedPreferences, property lists, JSON and images in place, with read-only SQL queries.
• See the traffic. A built-in proxy decrypts your app's HTTPS and lists every request with its headers, decoded bodies and timing, and exports HAR. One click points a device at it and another puts it back.
• Change the traffic. Mock a response, slow a request down, block it, or stop it and edit it, with rules and breakpoints. Read WebSocket messages, talk HTTP/3 to servers, and open packet captures.
• See the screen as a screen reader does. The layout of any screen, with an accessibility audit for missing labels, small touch targets and low contrast.
• Record a run. A session keeps the logs, CPU and memory, requests, crashes and screenshots of a run in one file. CI mode records around your test command and keeps its exit code.
• Everything about the device. OS and build, hardware, display, battery, storage and locale, with a live screen preview. Click any value to copy it.
• Native and light. A Rust core with a Tauri interface: a small download, a fast start and low memory use.
• Scriptable. The emulabzip command prints tables for people and JSON for scripts.
• Built on public interfaces. No private frameworks and no on-device agents, so it keeps working when Xcode and Android Studio update. Read how the official tools work.

Screenshots

_{Logs: logcat and the unified log, filtered as you type.}

_{Network: decrypted requests with bodies and timing, and the protocol each one used (h2, then h3).}

_{Rules: answer, slow down, block or hold a request, and see the result in the list.}

Layout: every view, with its name, size and flags.	Accessibility: touch targets, labels and contrast, with what to fix.
Sessions: a whole run in one file: errors, crashes, requests, CPU and memory.	Compare: two devices, their screens, charts and differences.

_{Traces: a CPU profile as a flame graph, coloured by whose code it is.}

_{Traces: a Perfetto system trace, summarized, with SQL and the Perfetto UI one click away.}

_{Crashes: crashes, native crashes and ANRs with their stacks and what to try next.}

Controls: another place, dark mode, a clean status bar, a low battery.

Plugins: your own collector, charted live, after you enable it.

Performance: CPU, memory, frames and battery, live.	Memory: snapshots, diffs and heap dumps.
Storage: SQLite, preferences and files, in place.	Devices: Android emulators and iOS simulators in one picker.

Features

	Android	iOS Simulator
Automatic device discovery	✅	✅
Device overview (OS, build, hardware, display, battery, locale)	✅	✅
Installed and running apps	✅	✅
Live log streaming with filters and export	✅	✅
Screenshots and live screen preview	✅	✅
Command line	✅	✅
CPU and memory charts	✅	✅
Frame rate, janky frames and battery charts	✅	—
Memory breakdown, snapshots and diffs	✅	✅
Heap dumps (.hprof) and memory graphs (.memgraph)	✅	✅
File browser with SQLite, preferences and property list viewers	✅	✅
Network inspector: decrypted HTTP(S), HAR export	✅	✅
Perfetto system traces with summary and SQL	✅	—
CPU flame graphs (simpleperf, Time Profiler) and Instruments recordings	✅	✅
Crashes, native crashes and ANRs, with stacks and hints	✅	✅ (crashes)
Device controls: location, dark mode, status bar, permissions, push	✅	✅
MCP server for AI assistants, and plugins	✅	✅
Mocks, delays, blocks and breakpoints; WebSocket messages; HTTP/3; packet capture import	✅	✅
Layout inspection and accessibility audit	✅	✅ (Simulator.app open)
Sessions, CI mode and comparing two devices	✅	✅

See the roadmap for what each phase contains.

Install

Desktop app

Download the installer for your system from the latest release: .dmg for macOS (Apple silicon and Intel), .msi or .exe for Windows, and .deb, .rpm or .AppImage for Linux.

You also need the tools for the platforms you work with:

• Android: the SDK platform tools (adb), which Android Studio installs.
• iOS: a Mac with Xcode.

Build from source

You need Rust (stable), Node.js 20 or newer and, on Linux, the Tauri system dependencies.

git clone https://github.com/LuisPeixoto/EmuLabZip.git
cd EmuLabZip/apps/desktop
npm install
npm run tauri build

Command-line only

cargo install --git https://github.com/LuisPeixoto/EmuLabZip emulabzip-cli

Pre-built CLI archives are attached to every release as well.

Quick start

emulator -avd Pixel_9            # or: xcrun simctl boot "iPhone 17"
emulabzip devices                # what is running
emulabzip info                   # what it is
emulabzip logs --level warn      # what it says
emulabzip screenshot             # what it shows
emulabzip perf --app com.example.app            # how fast it runs
emulabzip db com.example.app databases/app.db   # what it stores
emulabzip net --har capture.har                 # what it says to the internet
emulabzip a11y                                  # what a screen reader would trip over
emulabzip ci -o run.ezsession -- ./gradlew connectedCheck   # a recording around your tests

In the desktop app, pick the device in the top-left corner, then your app next to it. Read the getting started guide for a tour.

Documentation

Guide	What it covers
Getting started	Install, connect a device, find your way around
Android	How EmuLabZip talks to ADB, environment variables, device states
iOS Simulator	Requirements, what simctl provides, taming the unified log
Logs	Filters, regular expressions, pausing and export
Performance	What each chart measures and where the numbers come from
Memory	Snapshots, diffs, heap dumps and memory graphs
Storage	Storage roots, viewers and read-only SQL
Network	The proxy, the certificate, pinned apps and HAR export
Traces	Perfetto, simpleperf and Instruments recordings, flame graphs, SQL
Crashes	Crashes, native crashes and ANRs with their stacks, and where the reports come from
Mocks and breakpoints	Rules that answer, delay, block or hold requests
WebSocket messages	Reading frames, compression, limits
Packet captures	Importing .pcap and .pcapng, capturing with emulator -tcpdump
Layout and accessibility	The view tree, the audit and what it checks
Sessions	Recording a run into one file and reading it
CI mode	emulabzip ci around your tests, with a GitHub Actions example
Comparing devices	Two screens, two charts and the differences
Controls	Location, appearance, status bar, battery, permissions, notifications and links
MCP server	Letting an AI assistant read and control your devices
Plugins	Writing your own collectors, and the approval step
Command line	Every emulabzip command and option
Architecture	Crates, the backend trait, streams and design rules
How the official tools work	What we learned from Instruments and the Android Studio profilers
Troubleshooting	Devices that do not show up, empty logs, failing screenshots
Distribution	Releases, code signing and updates
Roadmap	What is done, and Phases 7 to 10 up to 1.0

Project layout

crates/
  emulabzip-core       Device model, log filters, streams and the backend trait
  emulabzip-adb        Async client for the ADB host protocol (devices, shell, exec, sync)
  emulabzip-android    Android backend: logcat, getprop, dumpsys, /proc, run-as, screencap
  emulabzip-apple      iOS Simulator backend: simctl, log stream, listapps, footprint, leaks
  emulabzip-storage    SQLite inspector, SharedPreferences and property list viewers
  emulabzip-net        Debugging proxy: certificate authority, TLS interception, flows, HAR, rules, WebSockets, HTTP/3, pcap import
  emulabzip-session    Recording a run into a .ezsession file, reading it back and summarizing it
  emulabzip-cli        The `emulabzip` command
apps/desktop
  src-tauri            Tauri 2 shell (Rust)
  src                  Svelte 5 + TypeScript + Tailwind CSS UI
tools/sample-app       A debuggable Android app with demo data, for trying the Storage tools

Contributing

Contributions of every size are welcome: bug reports, documentation, UI polish and new collectors. Start with CONTRIBUTING.md and look for issues labelled good first issue. Please follow the Code of Conduct. To report a vulnerability, see SECURITY.md.

License

MIT © Luis Peixoto and EmuLabZip contributors.