JetWhale is an extensible debugging tool inspired by Flipper.

It is built with Kotlin and Jetpack Compose, making it especially familiar and approachable for Kotlin / Android developers. Thanks to its Kotlin-first design, JetWhale can be introduced with a minimal learning curve.

The host (left) debugging the desktop demo app (right): live traffic, a mocked response, and a screen pushed from the Nav3 Navigator.

• 🐳 Multi-session debugging. Several apps stay connected at once, grouped by the device they run on.
• 🔌 Every tool is a plugin. Add one to a running host; the shipped inspectors work the same way as yours.
• 🛜 Type-safe messaging. Plugins exchange Kotlin types rather than hand-parsed JSON.
• ✅ Multiplatform. Android, Desktop (JVM), iOS (simulator and physical devices) and Web (JS / WasmJS).
• ⚙️ Zero Android setup. The host wires adb reverse for you.
• 🤖 MCP server (experimental). An AI agent can drive the app — screenshot, click, type, scroll, drag, read the accessibility tree.
• 🔥 Hot-reloadable plugin development. Edit a plugin and the host reloads it, without restarting.

[!NOTE] Under active development. Feedback is welcome as we work toward a stable release; the Plugin SDK APIs are not finalized and may still change.

📖 Documentation: https://kitakkun.github.io/JetWhale/

1. Install the host — download the installer for your OS from the releases page (.dmg for macOS, .deb for Linux, .msi for Windows), and launch it. macOS and Windows ask you to approve its first launch; see First launch. After that, you update it from inside the app.

2. Add the runtime to the app you want to debug:

// build.gradle.kts
dependencies {
    implementation("com.kitakkun.jetwhale:jetwhale-agent-runtime:<version>")
}

3. Start a session as early as you can in your app's startup:

startJetWhale {
    connection {
        endpoints {
            ws("localhost", 5080)
        }
    }
    plugins {
        // each inspector below is its own artifact; register the ones you want
    }
}

That is the whole integration — the app shows up in the host as soon as it runs.

See Getting Started for the rest, and Connecting Devices for physical devices and secure connections.

The debugging tools themselves are plugins. These ship with JetWhale — install one into the host from its plugin catalog; for one that works inside your app, also add the matching artifact to your app and register it in startJetWhale { }:

• Network Inspector — HTTP traffic with request and response bodies, plus mock rules that reshape responses without touching the server
• Compose Semantics Inspector — the Compose node tree of a running screen
• Nav3 Navigator — the Navigation 3 back stack, and pushing or popping entries from the host
• Debug Actions (experimental) — the app's debug menu as typed actions the host and AI agents can run
• Storage Inspector — the app's files, caches and key-value stores, with previews and deletion
• Device Mirror (experimental) — the live screens of Android devices and emulators, iOS simulators and iPhones, one at a time or in a grid, with screenshots and recordings per device; Android devices and simulators also take input. It runs in the host alone, with nothing to add to your app

Plugins are ordinary Gradle projects built against the published SDK. One command gives you a hot-reload loop:

./gradlew :myPlugin:runJetWhaleHot

It downloads a real host for your OS, launches it with your plugin loaded, and reloads the plugin on every source change without restarting.

See Developing plugins for the full guide.