Most Android teams using Jetpack Compose have a preview next to most of their components. Every button, card, empty state, and error screen has a small @Preview function with fake data. Together, they form the most complete and current picture of your app’s UI.
Yet the only person who sees them is the developer who wrote them, inside Android Studio.
Meanwhile, the designer asks for screenshots in Slack. QA can’t reproduce a screen’s error state without faking a backend response. A teammate on another feature builds a button that already exists two modules away. The answer to each of these was already in a preview, locked inside the IDE.
We built Arkive, an open-source Gradle plugin, to fix that. It turns your existing previews into a website anyone on the team can open from a link. Anyone can click an element to see exactly how it was built. On one of our large production apps, it cataloged 151 components across phone, tablet and desktop sizes, without a line of test code.
A UI catalog anyone can open from a link
Arkive records every preview as a snapshot on the JVM, with no emulator and no device. It then publishes the snapshots as a static website. Run ./gradlew generateWebShowcase and you get a catalog of every component, grouped by module and searchable with ⌘K.
Why a website
If you’ve looked for a Storybook for Android before, you probably found Airbnb’s Showkase. It’s a great library that does a lot of what you’d want. It generates dark mode, RTL, font scale and display scale versions of every component, and it supports screenshot testing. Unlike Arkive, it shows real components you can click and scroll.
But its browser lives inside your app. As its README puts it, “Showkase comes with an Activity that you need to start for accessing the UI browser.” To see a component, someone needs a device or an emulator and a debug build. A web version is on Showkase’s list of future ideas.
Newer tools get closer. compose-ai-tools has a browse command that opens a Storybook-like catalog in the browser. It runs as a local server on the developer’s own machine, though. Google’s Compose Preview Screenshot Testing plugin and Roborazzi produce HTML reports, but those are test reports for the person who ran the tests.
Arkive’s catalog is plain HTML, JSON and images. You build it once and host it anywhere a static site can live. Nobody needs the project, a device or Android Studio to open it. You can drop a link to a specific component into a Jira ticket or a design review. Our sample app’s catalog is live at https://infinum.github.io/arkive/ and redeploys on every merge.
Every state, side by side
Arkive expands @PreviewParameter values, so every state you wrote a preview for shows up: empty, loading, error, long text. Turn on variants and Arkive also records each component at a larger font scale, at different screen densities and in a right-to-left layout.
A compare mode puts any of them side by side. You can compare every state of a preview, every font scale, or LTR next to RTL. QA can check all of it without installing anything.
Designers get a direct line to the source of truth. Set your Figma file key once and add a node ID to a component with @ArkiveComposable(designNodeId = "..."). Its catalog page then links straight to the matching frame
Inspect mode: Why the UI looks the way it does
A screenshot shows what the UI looks like. It doesn’t tell you whether that title is 16 or 18 sp, or whether the padding is 12 or 16 dp. It also doesn’t tell you which composable drew the part that looks off.
A UI tree behind every snapshot
Next to every snapshot, Arkive writes a UI tree. Arkive builds it from Compose’s own layout and semantics trees, on the exact frame that was rendered. It adds source information about which composable emitted each node.
Each element gets its bounds in dp, its text and text style, and its accessibility semantics. It also gets the File.kt:line that drew it.
Recording the tree doesn’t change a single pixel of the snapshot. On our sample app, it added about 3% to recording time.
Click any element
That tree powers inspect mode. Press I (or click Inspect) on any component in the catalog, and Arkive outlines every element on the snapshot. Hover over one to see its size, spacing and font. Click it to pin the details, including the composable and the line of code behind it.
For a designer, that answers “is this 16 or 14 sp?” without opening Android Studio. For QA, missing content descriptions and cut-off text show up without a device or TalkBack. For a developer, a misaligned element points straight to the line that needs fixing.
For a designer, that answers “is this 16 or 14 sp?” without opening Android Studio. For QA, missing content descriptions and cut-off text show up without a device or TalkBack. For a developer, a misaligned element points straight to the line that needs fixing.
Your previews are already snapshot tests
Once Arkive records your previews, you already have everything a snapshot test needs.
No test code to write
Arkive generates the snapshot tests for you, from the previews. Google’s plugin and Roborazzi can also turn previews into tests. With Arkive, though, one recording builds both the catalog and the reference images. Your catalog and your tests can’t drift apart.
Set snapshotRetention to BASE, and Arkive keeps one reference image per component in your repo. That’s enough to catch regressions without committing every variant.
You pick Roborazzi or Paparazzi per module. If you already use one of them, Arkive works alongside your existing tests and reference images without touching them.
Every changed component, by name
Run ./gradlew verifyShowcase<Variant> in CI. If anything changed, the build fails and names every component that differs. It also saves a Reference / Diff / New image for each one.
To test this on our sample app, we changed the corner radius and padding of one shared component, the difficulty tag. Of the 33 components with a reference image, exactly the three that use the tag failed: the tag itself, the trail card and the trail detail screen.
When a change is intentional, you regenerate and commit the new images.
Where AI agents fit in
We built Arkive for human eyes, but machines can read everything above too. A JSON file lists every component in the catalog, and every UI tree is plain JSON.
AI agents often duplicate UI. Asked to build a screen, they’ll write a new button because they can’t see the one you already have. Arkive ships agent skills that use the catalog:
/arkive:findsearches the catalog and the source before anything gets built. It answers “use it,” “extend it” or “build new.”/arkive:design-loopputs a new screen’s snapshot next to its Figma frame. It compares the measurements from the UI tree as well as the pixels./arkive:snapshot-testingsets up reference images and explains failures when verification goes red. An agent can use it to check that its change didn’t break another screen.
What Arkive isn’t
Snapshots are static images.
Unlike Showkase, you can’t click or scroll through a component.
Rendering differs slightly from Android Studio
Unlike Showkase, you can’t click or scroll through a component.
A broken preview gets skipped.
Arkive logs it and the build carries on, so the catalog can quietly miss components. Check the log after the first run.
Paparazzi can’t render Compose Multiplatform resources.
Previews that read them fail and get skipped. Use Roborazzi for those modules.
Arkive targets AGP 9,
which needs Gradle 9.1+ and Kotlin 2.2.10+. Projects on AGP 8 can use Arkive 0.0.3.
Getting started
Arkive is on Maven Central. Apply it, together with KSP, to every module with previews. Apply it to the root project too, for the combined catalog:
plugins {
id("com.google.devtools.ksp") version "<ksp version>"
id("com.infinum.arkive") version "<latest version>"
}
arkive {
engine(Roborazzi) // or engine(Paparazzi)
}
Then run ./gradlew generateWebShowcase. If you use an AI agent, it can do the setup for you. Install the skills with npx skills add infinum/arkive and run /arkive:setup.
The catalog is a static site, so you decide who can see it. A browser has to load it from a server, not from a file on disk, but any static file server works. Use GitHub Pages for open-source projects. For client work, use an internal server or a CI artifact behind your company login.
Your previews already exist. Arkive gives them an audience, a magnifying glass and a safety net. Try the live demo.