What Spectra is, how it's built, and how it compares to Appium Inspector

I'm a QA engineer. For years my working day was Appium Inspector on one half of the screen and a test file on the other: tap the device, hit refresh, wait for the page source, click through the tree, copy a locator, paste it, run, repeat. On a good screen the refresh took a couple of seconds. On a screen with a spinner it took ten or more, or timed out. Hundreds of times a day.

Spectra is the inspector I built to get that time back. It's a native desktop app for inspecting Android and iOS app UIs, roughly 10MB, for macOS (Apple Silicon and Intel) and Windows. It generates locators and grades them, mirrors the device screen live, records gestures into test code, and works either through your existing Appium server or directly over ADB and WDA.

This post is the long version of that paragraph: what it is, how it's put together, what it does, and where Appium Inspector is still the better choice.

What Spectra is

Spectra sits where Appium Inspector, UIAutomator Viewer or the Xcode Accessibility Inspector sit in your workflow. You connect a device or simulator, you see the screenshot and the element tree side by side, you click an element and get its attributes and a list of locators. From there you copy a locator into your test, or export a snippet, or record a flow.

A typical session: plug in the phone, pick it in the connect dialog, and in Turbo Mode the screenshot and tree appear without an Appium server being started first. I click the button I care about, the Locators tab shows an A-graded accessibility ID at the top and a D-graded absolute XPath at the bottom, and I copy the one at the top. If the screen changes, the view follows without me touching anything.

What it doesn't do is replace your Appium server or your test framework. In Appium mode Spectra is a client of the same server your tests use, so what you see is what your tests will see. The direct mode is an addition for when you don't want a server in the middle, and you can switch between the two per session.

How it's built

The desktop shell is Tauri 2.0 with a Rust backend; the UI is React 18 with TypeScript, Zustand for state and Tailwind with Radix for components. Tauri uses the OS webview instead of bundling a browser, which is where the ~10MB and sub-second startup come from. Every ADB call, WDA request, screenshot capture and file operation runs in Rust and reaches the UI over Tauri's IPC.

There are two ways to talk to a device.

Appium mode speaks the WebDriver protocol to any Appium server, local or remote, typically with the UiAutomator2 or XCUITest driver behind it. Nothing about your Appium setup changes.

Turbo Mode skips the server. On Android, Spectra drives ADB directly for screenshots, input and the UI tree. On iOS it talks to WebDriverAgent over its HTTP API. Without the extra hop, inspection is 2 to 5x faster in my testing, and it's what makes live mirroring practical.

The third piece is the Spectra Agent, and it exists because of the spinner problem from the first paragraph. uiautomator dump calls waitForIdle() before it reads anything, and a screen with an animation is never idle, so the dump times out. The Agent is a small Android instrumentation APK (about a megabyte, some 450 lines of Kotlin) that Spectra installs when you connect in Turbo Mode. It reads the tree straight from UiAutomation.getRootInActiveWindow(), with no idle wait, and hands it back over a local socket forwarded through adb forward. It sends nothing anywhere else. If you don't want it on a device, adb uninstall com.spectra.agent removes it. There's a separate post with the details and the workarounds you can use without Spectra.

Licensing runs through Polar. A license key activates Pro on up to two machines. There's no account inside the app and no signup to download.

What it does

Turbo Mode (Pro). Direct ADB on Android and direct WDA on iOS, as described above, with no Appium server in the path.

LiveTrack (Pro). The screenshot and tree refresh on their own, with polling that adapts to how fast the device answers, and pause while the window is hidden. No refresh button in the loop.

Locator generation (Free). Eleven strategies: accessibility ID, resource-id, content-desc, text, XPath, iOS class chain, iOS predicate string, and Flutter key, type, text and semantics. Every candidate gets a grade from A to D based on how likely it is to survive a release (F-graded candidates are hidden). A Locator Builder lets you compose composite locators, and search covers text, attributes and locators.

Test Recorder (Pro). Record taps, swipes, long presses and typing on the real device, edit the steps, add assertions, replay, then export as executable test code. Think of it as codegen for mobile.

Code generation (Pro). Snippets and Page Object Model classes for WebdriverIO, Appium Python, Appium Java, Appium JS, XCUITest (Swift), Espresso (Kotlin), Detox (JS) and Maestro (YAML). As far as I know, no other inspector exports a recording to that many targets.

Multi-device (Pro). Two devices side by side, for example an Android phone and an iPhone on the same screen.

XPath Axis Builder (Pro). A visual builder for parent, sibling, ancestor and descendant relationships, for the times a plain attribute isn't enough.

Also in Free: device interactions (tap, swipe, long press, type, back, home), the Console, Logs, History and Network panels, a Prerequisite Checker that finds and installs missing ADB, Java or Appium pieces, auto-update with a "What's New" panel, and dark and light themes.

How it compares

Facts as of the current release, from the tools' own documentation and my use of them:

What Appium Inspector does better, and this matters: it's the reference client for the Appium project, it works with every Appium driver including ones Spectra doesn't target, most teams already know it, and it has no paid tier at all. If your team is standardised on it and the refresh wait isn't a daily cost for you, there is no reason to move. It also runs on Linux; Spectra ships for macOS and Windows only.

Who it's for, and who should stay put

Spectra is for QA engineers and SDETs who inspect mobile UIs many times a day and feel the wait; for automation engineers maintaining Appium, WebdriverIO, Python or Java suites who want a locator ranked before it goes into a page object; for Detox, Maestro, XCUITest and Espresso users who still need locators and don't want an Appium session just to read a tree; and for mobile developers checking accessibility IDs and layouts.

Stay on Appium Inspector if you inspect a few times a week, if you depend on a driver Spectra doesn't cover, or if you're not allowed to install a helper APK on test devices (you can still use Appium mode, but Turbo Mode's animated-screen support needs the Agent). Stay on UIAutomator Viewer if you're Android-only and it does what you need; it comes with the SDK and it's fine.

Free and Pro

Free is free forever and covers inspection: one device session, Appium mode, all inspection features, the eleven locator strategies with grades, the Locator Builder, search, device interactions, all four panels, the Prerequisite Checker, auto-update, both themes. Download and use it, no signup.

Pro is $7 a month or $50 a year, with a 14-day trial and two device activations per license. It adds Turbo Mode, LiveTrack, multi-device, code generation for the eight frameworks with Page Object Model output, the Test Recorder and the XPath Axis Builder. Teams that want volume licensing or a roadmap conversation can write to support@usespectra.dev.

What's next

Additional platforms and features are on the roadmap at https://usespectra.dev/roadmap, and there's a feature request form on the same page. I read every submission.

Spectra is free for inspection. Download at https://usespectra.dev.