Prevue

Close Android Studio. Your Previews still show.

Your Compose Previews, redrawn in the browser a second after you save.
Your agent sees the same screen.

English | 한국어

Get started →

_{Point at it, hot swap, interactive and every screen — real renders of Pearl, the sample app in fixtures/pearl.}

Your agent says the screen is done, so you open Android Studio and wait for the build to check it. You take a screenshot of what's wrong, explain it, and wait again. The agent writes the code, but you're still its eyes — every loop. Prevue redraws the Preview about a second after each save so the agent sees it for itself, and you step outside the loop and check only the finished screen.

Give it a design — a Figma frame, a screenshot, a mockup — and the agent edits, looks at the redrawn Preview, compares it with the design, and edits again on its own. You confirm the finished screen in your browser.

Make the ForYouScreen header match this screenshot

Screens that only change when you tap or drag work the same way. The agent switches the Preview into interactive mode, sends touches, and gets the new picture back.

Save, and the Preview redraws in about a second without Gradle. Change only a value — padding, a color, a string — and it takes about 0.2 seconds (Benchmark). Every @Preview in a file is laid out on a board grouped by function and redrawn on every save. The agent and you look at the same board, so "it's done" and "I see it" happen at the same moment.

_{Left: Now in Android (Apache-2.0) · Right: KotlinConf app, Compose Multiplatform (Apache-2.0)}

Kotlin Multiplatform and Compose Multiplatform modules work the same way. Prevue draws their commonMain Previews from the module's Android compilation, as Android Studio does, so modules that also target iOS or the web are fine. Compose Multiplatform resources (Res) draw as they do in the app.

Switch between a screen file and its component files while you edit, and the open files stay in the list on the left. / or ⌘K finds a file by name, initials (fys → ForYouScreen.kt), or Preview function name. Press ? in the viewer for every shortcut.

Click anything in the Preview and tell your agent what to do with it. No screenshots, no "the second card from the top."

Tighten the padding on this

The agent reads "this" as a file and line. @path#Lline is also copied to your clipboard, so you can paste it into a terminal.

A card opens beside the picture with what you pointed at: its name, its file:line, its size and its modifiers, plus a small tree of the elements around it. Click a row to point at a parent or a sibling, or jump to a Preview that calls it.

Press a card's ▶ to open it large. Like Android Studio's Interactive Mode, click and drag to check motion and animations. Without touching the source, change the screen size or the device (six Android, four iPhone), turn it to Portrait, Landscape left or Landscape right, and fold or unfold foldables.

• Real device insets reach your Composable, from windowinsets.info and safearea.info.
• Show inset areas draws each inset band and the safe area over the picture.
• Each device draws its own system UI — Android, iOS and iPhone Duo status bars, in the browser only.

One Preview in Android Studio keeps a Gradle daemon and a Kotlin daemon running too, about 8GB. We gave three agents a worktree each on a 36GB Mac, and the three Android Studios started swapping until every task slowed to a crawl.

With Prevue, every worktree gets its own lightweight daemon, each using 83% less memory than Android Studio (Benchmark). Even when two agents save at the same time, each window redraws on its own, and when only one saves again, the other stays put.

• macOS with the Command Line Tools (python3) — if they're missing, the agent opens the installer for you.
• Java — with Android Studio Ladybug (2024.2) or newer installed, there's nothing to set up, even if your project uses JDK 17.
  • Older Android Studio releases bring Java 17, which the preview server can't run on.
  • Without Android Studio, install JDK 21 or later. brew install openjdk@25 needs no sudo, and Prevue finds it there (or under Library/Java/JavaVirtualMachines or SDKMAN) by itself. 25 or later starts about a second faster.
  • Set PREVUE_JDK only to pick a different one.
• Android SDK — with at least one platform. Set ANDROID_HOME if it isn't at ~/Library/Android/sdk.

# Claude Code
claude plugin marketplace add https://github.com/kakao/prevue.git
claude plugin install prevue@prevue

# Codex
codex plugin marketplace add https://github.com/kakao/prevue.git
codex plugin add prevue@prevue

Then tell your agent the file name. Calling the skill directly is more reliable: /prevue in Claude Code, $prevue:prevue in Codex.

Show the Previews in ForYouScreen.kt

Kotlin Multiplatform and Compose Multiplatform projects work the same way: name a file in commonMain.

There's nothing to configure. The first time you run it, the agent does the setup it needs, checking with you as it goes. When it's done, your browser opens with every @Preview in that file. Prevue doesn't change your project's build files, plugins, or tasks, and it doesn't add files to your project. Gradle runs only once per module; after that, even edits to shared modules redraw right away.

Refresh the marketplace info first, then update the plugin. If you skip this step, it reads the old version info and says it is already up to date.

# Claude Code — takes effect after a restart or /reload-plugins
claude plugin marketplace update prevue
claude plugin update prevue@prevue

# Codex — there is no update, so run add again
codex plugin marketplace upgrade
codex plugin add prevue@prevue

Changes are in CHANGELOG.md. If you get stuck, ask your agent to read prevue log. If that doesn't help, let us know in an issue.

Top, the same work in Android Studio and in Prevue. Bottom, how fast each kind of change shows up.

• Setup — Apple Silicon, 14 cores · 36GB RAM · nowinandroid ForYouScreen.kt (25 Previews). Android Studio 2026.1.3 was measured on 2026-09-22 and Prevue (develop feb5c6e) on 2026-10-23. Prevue values are medians
• Hot Swap — From save until all 25 show the new picture. The first one appears at 0.9 seconds
• First Preview — Android Studio from opening the project, Prevue from starting the daemon, until the first render finishes
• Memory — Android Studio is the IDE plus the Gradle daemon at one moment; Prevue is the memory use of its one daemon after 10 saves. Going back and forth between modules for a long time, it peaked at 1.6GB, and it shuts itself down after 10 minutes without use
• Disk — The Android Studio app bundle vs ~/.prevue/toolchain. With JDK 25 or later Prevue also keeps a class cache of about 200MB in ~/.prevue/aot that makes the daemon start faster
• How fast Prevue redraws — Literal and resource-value saves skip compilation. Switching modules and changing devices are measured until the new picture is ready. Interactive is the frame rate on the viewer stream while dragging a feed

These are commands the agent calls, so you rarely type them. The executable is bin/prevue in the directory where the plugin is installed. See every command and exit code with prevue --help, and each command with prevue <command> --help. Four are worth typing yourself.

This software is licensed under the Apache 2 license, quoted below.

Copyright 2026 Kakao Corp. http://www.kakaocorp.com

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this project except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.