Android Studio Quail is in canary: the four features actually worth a look

Android Studio’s next codename is Quail, and the first canaries are out. Canary 1 dropped on April 16, Canary 4 landed on May 7. If you’ve been wondering what comes after Otter: it’s Quail 1 (2026.1), due to follow the usual canary, beta, stable cadence through the rest of the year.

I’ve spent a few hours with Canary 4 on a side install. Most of it’s the kind of polish you stop noticing within a day. But four things stood out enough that I’d recommend installing the canary if you’re working on anything serious. One of them changes how you triage a crash. Another swallows a tool most of us already had bolted onto our debug builds.

What “Quail” is, briefly

Quail is the next major Android Studio release, version 2026.1.1. It follows the alphabetical animal codename pattern (Otter was 2025.2), and it sits on top of whatever IntelliJ Platform line Google has settled on. Right now that’s somewhere in the 2026.1 range, though they don’t always bump the IntelliJ version in lockstep with the canary number.

Canary track is the usual deal. Install it next to your stable IDE, point it at a clone of your project, and assume the Gradle sync will fight you at least once. I keep mine on a separate JBR runtime so a wedged build daemon doesn’t ruin a normal day.

The headline: AI crash fixes from App Quality Insights

This is the feature that justifies the install on its own. The App Quality Insights tool window (the panel that shows you Crashlytics and Play Console issues from inside the IDE) is now wired to the Gemini agent.

Pick a crash. Open the Insights tab. There’s a See more button for a longer natural-language explanation of what’s probably going wrong, and a Fix with AI button that drafts a code change across the relevant files. You review and accept (or reject) it like any agent edit.

Otter’s version of this surface was an explain-only feature. It would tell you what the stack trace meant. Quail is the first time the agent actually tries to fix the crash from the same panel, with both the production stack trace and your source as context.

How well does it work? Decent on the obvious stuff: null derefs, lifecycle bugs, the “oh right, I never closed the cursor” class of mistake. It struggles when the fix needs broader knowledge of your architecture — state hoisting, threading rules, weird ProGuard interactions. Useful as a head start. Don’t skip reading the trace yourself.

LeakCanary moves into the Profiler

Square’s LeakCanary has been the default memory-leak tool on Android for years. Google has now turned it into a first-party Profiler task. Pick LeakCanary from the Profiler’s task list and the analysis runs against your connected app from inside the IDE, instead of nagging you via a notification on the device.

The leak report has a Jump to Source button now, so clicking a node in the retention path drops you into the right file on the right line. That alone removes most of the friction of using LeakCanary on a real codebase. You also no longer need a debug-instrumented build for it: the Profiler version attaches at runtime, which is handy when you’re handed a build flavor you can’t easily rebuild yourself. And there’s a Copy for Gemini button right next to the report. One click pastes the retention path into the Gemini chat with context, and the agent will at least propose where the reference is being held. Same caveat as the AQI feature: it does well when the leak is in your code, less so when the culprit is buried in someone else’s library.

If you’ve been putting off LeakCanary because adding the dependency to a build felt like overhead, Quail is the version where that excuse stops working.

Compose Preview Screenshot Testing, finally a tool

Screenshot testing for Compose has existed in pieces for a while. Paparazzi, Roborazzi, an experimental Gradle plugin from Google. None of them first-party until now. Quail ships a Compose Preview Screenshot Testing tool that takes your existing @Preview functions, renders them, and diffs them against a baseline.

Output is an HTML report with side-by-side images. Drop it in CI and every PR that touches a composable picks up a visual gate. No emulator required: rendering happens on the JVM via Layoutlib, the same renderer behind the design-time preview.

It’s not a replacement for an on-device test when animation or hardware behaviour matters. But it catches the failure mode that costs teams hours every release: someone tweaks a padding token in the design system and silently shifts every screen by 4dp. That’s most of the value, and it’s value people have been wanting from the IDE for a long time.

Recomposition state reads in the Layout Inspector

If you’ve ever watched the recomposition counter in the Layout Inspector tick into the hundreds and had no idea which state change was responsible: this one is for you.

Quail’s Layout Inspector now shows you, per composable, the state variables that were read during the last recomposition, plus the stack traces that invalidated them. A navigation arrow walks you backwards through the recomposition history, and an Explain with AI button turns the stack trace into a paragraph of English.

It needs androidx.compose.ui:ui:1.10.0 (BOM 2025.12.01) or higher. On older Compose versions the panel just doesn’t populate. Bumping the BOM is usually a small change. If it isn’t for you, that’s its own warning sign.

The smaller stuff worth knowing

Material symbols in the Vector Asset Studio

The Vector Asset Studio used to list a frozen subset of the old Material Icons set. Quail wires it to the live Material symbols library, which is the system Material 3 uses by default. You can pick weight, grade, and optical size before importing (the same axes the Google Fonts symbols UI exposes), and Studio drops a vector drawable into the project.

Saves a trip to fonts.google.com per icon. Quality-of-life, nothing more, but if you’re shipping a Material 3 app this is the icon flow you’d want anyway.

Agent mode for dependency updates

Gemini’s agent mode now has a dedicated dependency-update workflow. Tell it to update the project and it walks the version catalog, opens build files, runs Gradle sync after each bump, tries to fix compile errors from API changes, then produces a report at the end.

I’d give it patch and minor bumps for well-behaved libraries before trusting it with AGP or a Kotlin major version. For the chore of working through 30 out-of-date dependencies in an old project, though, this is the first AI feature in the IDE that’s actually saved me an afternoon rather than a few minutes.

Should you install the canary?

Yes, on a side install. The AQI agent integration and the Layout Inspector state-read panel are the kind of features that change how you debug, and there’s no real way to evaluate them from a release-notes page. You have to point them at a real bug.

A few things to know before you make Quail your daily driver:

• Canary builds break. Canary 4 has been solid in my short use, but earlier ones had a Gradle daemon hang that ate a workday for at least one team I know about. Keep it as a side install, on a separate Gradle home.
• Plugin compatibility lags the canary. If you depend on a JetBrains marketplace plugin that hasn’t updated to the new IntelliJ platform release, it’ll sit disabled until the maintainer ships a new build.
• Gemini features need an active sign-in. The AI panels work on the free tier, but rate limits hit faster than they used to. If you’re planning to lean on the AQI agent, a paid tier on a work account is the path of least resistance.

Where to grab it

Canary downloads live at developer.android.com/studio/preview. Stable is months away, so the canary is the only path to Quail today. Release notes for each new build go up at androidstudio.googleblog.com (cadence is roughly fortnightly), and the closed-bug list for 2026.1.1 lives at developer.android.com/studio/releases/fixed-bugs/studio/2026.1.1. That last one’s worth a glance when you’re triaging whether your favourite weird bug got quietly fixed.

Beta most likely lands sometime over the summer, with stable in the back half of the year. Google I/O on May 19–20 will almost certainly cover Quail in the developer keynote. Our I/O preview has the rest of the schedule if you want it.