2014 – 2026

Android Studio Versions

Every public stable release of Android Studio — Android Studio 1.0 in December 2014 through the current alphabetical-animal codename line — with the minimum supported Android Gradle Plugin, Gradle, Kotlin Gradle Plugin, and JDK versions for each Studio release. Each cell is a floor, not a target: the least you have to upgrade to keep building. Plus the IntelliJ lineage, the Eclipse-ADT replacement, the codename arc, and a JDK explainer for the three different JDKs that get conflated when the build complains.

Current Google Play Store submission floor

As of August 31, 2026: new app submissions to the Google Play Store — and updates to apps already on it — must target Android 16 (API 36) or later. The minimum Android Studio that compiles against API 36 is Meerkat (2024.3.1 Patch 1, AGP 8.9.1) — the row marked with the amber left edge and the Play Store Min badge below.

The step took effect on August 31, 2026, replacing the Android 15 (API 35) requirement that had stood since August 31, 2025. The marked floor row has moved up two lines accordingly, from Koala to Meerkat. If you need more time, Google will grant extensions through November 1, 2026, and as of this refresh (September 15, 2026) the request mechanism is live: the Help article’s FAQ now places the extension form on the details page of the warning on Play Console’s Policy status page, and says only apps that have already drawn a non-compliance warning receive one. Google’s two sources contradict each other on this point — a pair of older paragraphs in that same article, and the whole of the developer-site page, still say the forms will appear in Play Console “later this year” — but the FAQ is the only one that names a location, so it is the one to act on. Per-form-factor floors sit lower: Wear OS and Android Automotive OS submissions stepped to API 35 on the same day, Android XR stepped to API 34, and Android TV’s API 34 floor has stood since August 31, 2025. No further target-SDK step has been announced beyond this one.

Google’s policy pins the target SDK level, not the Studio version directly — but compiling against API 36 requires AGP 8.9.1+, which requires Studio Meerkat (2024.3.1 Patch 1) or newer. Anything below the Meerkat line can’t produce a Play Store-compliant build today. A separate availability rule stepped up on the same date and is now also in force: an app already on Play that targets below Android 15 (API 35) is no longer offered to new users whose devices run a newer Android version than the app targets — so the availability floor sits one API level below the submission floor, at the Koala line. Both of Google’s published sources carry the step: the developer-site target-SDK page and the Play Console Help article. The Help article is the policy source of record — it posted the August 31, 2026 date roughly two months before the developer-site page caught up. Google announces target-SDK floor changes via developer.android.com/google/play/requirements/target-sdk and the Play Console Help target API level requirements article; this strip is refreshed on a tighter sub-cadence than the historical matrix below.

Era, bundled JDK & Play Store status

Naming era

Sequential — 1.0 – 4.2, 2014–2021, sequential major.minor numbering

Animal codename — Arctic Fox onward, 2021+, IntelliJ-aligned YYYY.N.P versioning + alphabetical animals

Bundled JDK

JDK 8 — Studio 1.0 through 4.2

JDK 11 — Arctic Fox through Electric Eel

JDK 17 — Flamingo through Koala

JDK 21 — Ladybug onward

Play Store status

Play Store Min — the floor itself: the lowest Studio that compiles against the currently-required Play Store target SDK. Marked with the amber left edge.

Above the floor — rows above the marked row support the required compileSdk and beyond.

Below floor — rows below can’t compile against the required target SDK; new submissions will fail Play Store policy.

Studio × AGP × Gradle × Kotlin × JDK — minimum supported

Each row is one Studio release; each cell in the AGP, Gradle, Kotlin (KGP), and JDK columns is the minimum supported version for that Studio. Higher versions in the same major line generally work; lower versions don’t. Read it as a floor: when an upgrade forces your hand, do the least you can get away with.

Studio

AGP min

Gradle min

Kotlin (KGP) min

JDK

Notable

Studio

Quail

2026.1.1 → 2026.1.4 · Jun – Sep 2026

9.4

9.6.0

2.2.10+

21 bundled

Current Stable. IntelliJ 2026.1 base. Quail 4 (Sep 1, 2026) holds the AGP 9.4 ceiling — Gradle 9.6.0 floor. Four Stable builds since June — an in-IDE MCP Marketplace, agent-driven merge-conflict resolution, Firebase setup from Agent Mode, and Gemma 4 running locally inside the IDE.

AGP 9.4 ceiling + Gradle 9.6.0 floor (Quail 4). The line has raised its AGP ceiling three times: Quail 1 shipped with the AGP 9.2 ceiling it shared with Panda 4 (Gradle 9.4.1), Quail 2 and Quail 3 sat on AGP 9.3 (Gradle 9.5.0), and Quail 4 moved to AGP 9.4 — Google’s Studio-to-AGP table lists 2026.1.4 as requiring AGP 7.1–9.4. AGP 9.4 requires Gradle 9.6.0 and SDK Build Tools 36.0.0, needs a build JDK of 17 or higher, and still supports a maximum API level of 37 (JDK 21 bundled to run Studio itself). Built-in Kotlin still requires KGP 2.2.10+ — AGP 9.4’s own notes state no Kotlin minimum, so that floor carries forward from the AGP 9.0.0 release notes. Per the AGP 9.4.0 release notes.
IntelliJ 2026.1 base (platform branch 261).
Quail 1: 2026.1.1, June 2, 2026 (Patch 1: June 11, 2026 — minor bug-fix update; per the release notes, from Quail 1 onward org.gradle.parallel=true no longer enables parallel model fetching during Gradle Sync — set org.gradle.tooling.parallel=true instead). Google frames the release as “essential bug fixes and the latest IntelliJ platform improvements.”
Patch 2: June 16, 2026. General bug fixes only (e.g. a fix for the Gemini “Model Providers → Add → Local Provider” dialog opening the wrong configuration screen); no new headline features. This was Quail 1’s final shipping build before Quail 2 superseded it. Per developer.android.com/studio/releases and the Android Studio Release Updates blog (2026-07-09).
Quail 2: 2026.1.2, July 14, 2026. Released together with AGP 9.3.0 — the release that set the cell values above. Google describes it as “minor fixes and improvements”; it carries no new headline feature, but the AGP bump raises the Gradle floor from 9.4.1 to 9.5.0, so it is a required-Gradle-upgrade release for anyone moving off Quail 1. Per the Android Studio Release Updates blog and the 2026.1.2 closed-issues list.
Quail 2 Patch 1: July 23, 2026. A Stable-channel bug-fix patch on the same 2026.1.2 build, released together with AGP 9.3.1, which fixed no publicly-tracked issues. Google’s closed-issues list for 2026.1.2 has since grown a second entry under the same “Patch 1” heading, this one shipping AGP 9.3.2 and fixing a lint crash on JDK 17 (issue #522845800 — NoSuchMethodError: java.util.List.removeLast() in the bundled intellij-core JavaDocParser). The AGP 9.3.0 release notes carry the same 9.3.2 fix, but neither page dates that build and the Release Updates blog never announced it, so whether it is a second patch or a re-release of the first is not something Google states. The floors are unchanged either way — the whole AGP 9.3 line requires Gradle 9.5.0 — so it is a drop-in update for anyone still on Quail 2. Per the Android Studio Release Updates blog, the 2026.1.2 closed-issues list, and the AGP 9.3.0 release notes.
Quail 3: 2026.1.3, July 30, 2026 — the line’s current major build, and the cell values above. Required AGP range is unchanged from Quail 2 (7.1–9.3), so it is not a forced-Gradle-upgrade release. Three new features: Planning Mode improvements (a /plan command kicks off a multi-stage reasoning pass; you review, comment on, and iterate the plan before the agent spends tokens executing it, and get a change summary afterward); an MCP Marketplace under Settings → Tools → AI → MCP Servers that browses and installs the servers listed on ModelContextProtocol.io, with a custom-registry switch and NPX / Docker / Python filters; and a Merge Conflicts with Agent button in the Commit tool window that launches an agent session against the conflicting files. Per developer.android.com/studio/releases and the Android Studio Release Updates blog.
Quail 3 Patch 1: August 10, 2026 — the last build on the Quail 3 line. A Stable-channel bug-fix patch on the same 2026.1.3 build. It names no accompanying AGP release, and the Studio-to-AGP table still lists 2026.1.3 as requiring AGP 7.1–9.3 — so every floor above is unchanged. Google’s closed-issues list now enumerates three Gemini fixes for this patch, one of them filed at severity S0 critical: an agent-driven data-loss defect in which the AI agent executed a malformed shell command that deleted drive contents (issue #540709807, also fixed in the Quail 4 and Rabbit 1 preview branches). The other two cover Agent Mode errors against the Gemini Flash 3 model and an AI commit-message window that re-prompted for sign-in when already authenticated. If you are running Quail 3 with the agent enabled, this patch is the one to take. Per the Android Studio Release Updates blog and the 2026.1.3 closed-issues list.
Quail 4: 2026.1.4, September 1, 2026 — the line’s current shipping build, and the cell values above. Released together with AGP 9.4.0, which lifts the Gradle floor from 9.5.0 to 9.6.0 — so unlike Quail 3, this one is a forced-Gradle-upgrade release for anyone moving up from Quail 3. Google summarises the build itself as “minor fixes and improvements,” but four features land with it: Firebase in Agent Mode (Authentication and Cloud Firestore can be enabled and configured from the agent chat through Firebase agent skills, so backend setup no longer means leaving the IDE); recomposition state reads in the Layout Inspector (click a node’s recomposition count to see which state variables were read and which of them actually changed, step back through previous recompositions, and ask for a natural-language “Explain with AI” breakdown — needs compose.ui:ui:1.10.0 / BOM 2025.12.01 or higher); Gemma 4 integration (an integrated runtime executes the model on-device, so AI code assistance no longer depends on a third-party host — Settings → Tools → AI → Model Providers → Gemma); and a predictive-back simulator in Compose Interactive Preview (a Navigate Back action plus a Predictive Back Progress slider, so back and forward transitions can be stepped through without deploying to a device). Two AGP 9.4 behaviour changes are worth reading before the upgrade: the build now checks for strict 1:1 flavor-dimension parity between app and dynamic-feature modules, reporting mismatches as warnings by default (promotable to hard errors with android.enforceDynamicFeatureVariantMatching=true) and failing builds outright from AGP 10.0; and the new Variant API becomes mandatory in AGP 10, with android.newDsl.optOut as the per-module escape hatch until then. Per developer.android.com/studio/releases, the Android Studio Release Updates blog, the 2026.1.4 closed-issues list, and the AGP 9.4.0 release notes.
What’s in preview behind it. The next animal codename, Rabbit, opened in Canary on August 17, 2026 and has reached Canary 5 (September 10), carrying AGP 9.5.0-alpha05. It is the only preview line running as of this refresh — no Beta-channel build has been announced since Quail 4 RC 2 graduated to Stable on September 1. Preview builds don’t get a row here; the matrix is Stable-only.
Suggested fixes for crashes with Agent integration in App Quality Insights (Quail 2) — the AQI tool window analyzes a selected crash alongside your source and offers “See more” explanations plus a “Fix with AI” agent action that proposes reviewable code changes.
Always confirm exact pinning against developer.android.com/studio/releases — the matrix here is refreshed quarterly.

Studio

Panda

2025.3.1 → 2025.3.4 · Feb – Apr 2026

9.2

9.4.1

2.2.10+

21 bundled

Prior Stable line. IntelliJ 2025.3 base. Panda 4 (Apr 2026) bundles AGP 9.2.0 — Gradle 9.4.1 floor. Four Feature Drops — idea-to-prototype Agent flows, AI dependency upgrades, Next Edit Prediction, Planning Mode, Ask Mode, Agent Web Search.

AGP up to 9.2 + Gradle 9.4.1 floor. The Panda line spans AGP 9.0 (Panda 1) through AGP 9.2 (Panda 4); the current shipping floor is AGP 9.2.0, which requires Gradle 9.4.1. Built-in Kotlin support requires KGP 2.2.10+; AGP's build JDK must be 17+ (JDK 21 bundled to run Studio itself). AGP 9.2's maximum supported API level is 37.0.
IntelliJ 2025.3 base.
Panda 1: 2025.3.1, Feb 2026. AGP up to 9.0. Create-a-new-project-with-AI groundwork; AI agent dependency upgrades.
Panda 2: 2025.3.2, Mar 2026. AGP up to 9.1. Create a new project with AI (idea to app prototype); update dependencies with the AI agent; monochrome icon support in Asset Studio; Custom View Preview and Layout Inspector 3D mode deprecated.
Panda 3: 2025.3.3, Apr 2026. AGP up to 9.1.
Panda 4: 2025.3.4, Apr 2026 (Patch 1: May 2026). AGP up to 9.2 (bundles AGP 9.2.0). Next Edit Prediction (away-from-cursor AI suggestions across files); Planning Mode (agent drafts a multi-step plan first); Ask Mode replaces the Ask tab; Agent Web Search; Generate unit tests with Gemini; Gemini API Starter template; Google One AI Pro/Ultra integration; developer-verification build-time checks.
Always confirm exact pinning against developer.android.com/studio/releases — the matrix here is refreshed quarterly.

Studio

Otter

2025.2.1 → 2025.2.3 · Oct 2025 – Jan 2026

9.0

9.1.0

2.2.10+

21 bundled

First Studio Stable on the AGP / Gradle 9.x line. AGP 9.0 (Gradle 9.1.0 floor). Three Feature Drops — Settings Backup & Sync, Android Knowledge Base, any-LLM Studio AI, Agent Mode multi-thread + MCP, natural-language Journeys.

AGP 9.0 + Gradle 9.1.0 floor — the first Studio Stable that requires the AGP / Gradle 9.x line (AGP 9.0 requires Gradle 9.1.0). Built-in Kotlin support requires KGP 2.2.10+; build JDK must be 17+ (JDK 21 bundled to run Studio itself). The most consequential floor bump on the page since the AGP 8.0 → AGP 8.x line opened in Iguana / Jellyfish — build scripts using removed Gradle APIs need migration.
Kotlin Multiplatform plugin on Windows / Linux — previously macOS-only since the Narwhal 2025.1.1 release.
IntelliJ 2025.2 base.
Initial Stable: 2025.2.1, Oct 30, 2025.
Feature Drop 2: 2025.2.2, Dec 2025. Android Knowledge Base for Gemini-in-Android-Studio's Agent Mode (continuously-updated platform-code knowledge to reduce post-training-cutoff hallucinations); Settings Backup & Sync (back up Studio settings to Google or JetBrains cloud accounts); Compose UI tooling polish (resizable previews, faster preview navigation).
Feature Drop 3: 2025.2.3, Jan 2026. LLM flexibility (Studio's AI features can be powered by any LLM, not only Gemini, with bring-your-own-key configurations); Agent Mode improvements (multiple conversation threads, easier review-and-accept of suggested changes, deeper on-device app interaction, ability to connect to remote MCP servers); Journeys (run user-journey tests using natural-language descriptions, translated to device interactions by the test runner).
Cloud services are being switched off for this line. Google’s Cloud-services compatibility window covers the latest Stable plus major versions released in the previous 10 months, and with Quail 4 out the frontier has advanced within this line: the initial Otter build (2025.2.1) has dropped out of the window entirely, and Otter 2 Feature Drop (2025.2.2) is now the build Google marks deprecated — it will have Gemini in Android Studio, Play Vitals, and Firebase Crashlytics integration disabled at the next major release. Otter 3 Feature Drop and everything newer remain supported. The IDE keeps building either way; only the service integrations stop. Anyone still on Otter should plan the move to Panda or Quail.
Always confirm exact pinning against developer.android.com/studio/releases — the matrix here is refreshed quarterly.

Studio

Narwhal

2025.1.1 → 2025.1.4 · Jun – Oct 2025

8.11

8.13

2.0+

21 bundled

IntelliJ 2025.1 base. Continued K2 / Compose tooling improvements. First Stable to include the Kotlin Multiplatform plugin (macOS only). Four Feature Drops through October 2025 — Agent Mode, XR emulator, Play Policy Insights, Watch Face Format editor.

IntelliJ 2025.1 base. Inherits the IntelliJ Platform UI refresh and the K2-by-default Kotlin tooling that JetBrains shipped in IntelliJ 2025.1.
Bundled JDK 21. Narwhal shipped together with AGP 8.11.0, which requires Gradle 8.13; Google’s Studio-to-AGP table lists 2025.1.1 as accepting AGP 3.2–8.11.
Kotlin Gradle Plugin 2.0+ required; the K2 compiler is the default backend for new projects.
Continued refinement of the Compose Preview, hot-reload, and Live Edit pipelines that landed across Koala and Ladybug.
Narwhal: 2025.1.1, Jun 24, 2025. First Stable to include the Kotlin Multiplatform plugin (macOS only). K2 compiler default for new projects. Shipped with AGP 8.11.0 / Gradle 8.13.
Narwhal Feature Drop: 2025.1.2, Jul 2025 (Patch 1: Aug 2025). Gemini Agent Mode debuts — complex multi-stage tasks spanning multiple files, with plan-and-iterate flow. Rules in Gemini for persistent coding-style preferences. XR Emulator launches embedded in Studio. New XR project template. 16 KB page size support and proactive APK compatibility warnings. Compose Preview navigation improvements.
Narwhal 3 Feature Drop: 2025.1.3, Sep 2025. Resizable Compose Previews (drag-to-resize). Build files now displayable under their module in Android View. Play Policy Insights as lint checks — in-IDE guidance on Google Play policies. Test and develop with app backup and restore tooling.
Narwhal 4 Feature Drop: 2025.1.4, Oct 2025. Agent Mode stable and default when invoking Gemini; Chat renamed to Ask. Android SDK Upgrade Assistant adds Android 16 / API 36 migration path. Watch Face Format editor support (code completion, error validation, resource linking, direct deploy).
Always confirm exact pinning against developer.android.com/studio/releases — the matrix here is refreshed quarterly.

Studio

Meerkat

2024.3.1 → 2024.3.2 · Mar – May 2025

8.9

8.11.1

2.0+

21 bundled

Play Store MinThe Meerkat line is the minimum Studio that compiles against API 36 (Android 16) — the current Play Store target-SDK floor (Meerkat 2024.3.1 Patch 1 / AGP 8.9.1). First Studio on JDK 21 line to mature. Gemini in Android Studio polish. Feature Drop (May 2025) adds Prompt Library, themed icon preview, and Gemini Agent Mode rules.

Play Store submission floor as of August 31, 2026. Google Play requires new app submissions and updates to existing apps to target Android 16 (API 36) or later. Per Google’s minimum-tools-per-API-level table, compiling against API 36 needs AGP 8.9.1+ — the exact minimum build is Meerkat 2024.3.1 Patch 1 (March 2025) — so the Meerkat line is the smallest Studio that produces a Play Store-compliant build. It replaced the Koala line, which had held the floor since the API 35 requirement took effect on August 31, 2025. Developers who need longer can request an extension through November 1, 2026. See the submission-floor strip at the top of the page for the most recent target-SDK announcement.
IntelliJ 2024.3 base. Bundled JDK 21; minimum Gradle 8.11.1; minimum AGP 8.9.
Kotlin Gradle Plugin 2.0+ required — the K2 compiler is now the recommended default for Android projects.
Refined Gemini-in-Android-Studio integration: code completion, generation, and refactoring suggestions.
Compose Preview improvements; the Layout Inspector for Compose hierarchies continues to converge with the View-system inspector.
The first Stable on the JDK-21 ramp that most non-bleeding-edge teams adopted; widely-reported as the “just upgrade to this” release of early 2025.
Meerkat: 2024.3.1, Mar 2025 (Patch 1, March 2025, is the build Google names as the minimum for compiling against API 36).
Meerkat Feature Drop: 2024.3.2, May 2025. Prompt Library for Gemini — save and share frequently used prompts at IDE or project level. Themed icon preview for Android 13+ dynamic theming. Android Studio config directory now includes a micro-version suffix to allow Feature Drop and Stable releases to coexist. Continued Gemini Agent Mode refinements (Rules in Gemini via Prompt Library).

Studio

Ladybug

2024.2.1 → 2024.2.2 · Oct 2024 – Jan 2025

8.7

8.9

1.9.20+

21 bundled

JDK shifts from 17 to 21. Largest upgrade-pain release in the Studio line since Flamingo.

Bundled JDK jumps from 17 to 21. The first Studio version to ship JDK 21; projects that pinned org.gradle.java.home to a JDK 17 install often broke on first sync.
Minimum Gradle 8.9; minimum AGP 8.7.
IntelliJ 2024.2 base. The platform-wide UI refresh (compact tabs, restructured tool window) that landed in IntelliJ 2024.x carries through.
Kotlin Multiplatform tooling significantly improved; iOS module support for KMP projects became less rough-edged.
Ladybug Feature Drop: 2024.2.2, Jan 2025. The line’s second and final Stable build; Meerkat then continued the JDK-21 line.

Studio

Koala

2024.1.1 → 2024.1.2 · Jun – Aug 2024

8.5

8.7

1.9.0+

17 bundled

Minimum Studio that compiles against API 35 (Android 15) — the Play Store submission floor from August 2025 until August 31, 2026, and still the availability floor for apps already on Play. Final JDK-17 Stable line. Gemini in Android Studio launches.

Held the Play Store submission floor from August 31, 2025 to August 31, 2026. For that year Google Play required new app submissions to target Android 15 (API 35) or later, and compiling against API 35 needs AGP 8.6+ — the exact minimum being Koala Feature Drop (2024.1.2, August 2024) with AGP 8.6.0. On August 31, 2026 the submission requirement rose to Android 16 (API 36) and the floor moved up to Meerkat (2024.3.1 Patch 1). Koala still matters for a narrower reason: API 35 remains the availability threshold, so an app already on Play that targets below API 35 — i.e. was built below this line — is no longer offered to new users on newer Android versions. See the submission-floor strip at the top of the page for the current requirement.
IntelliJ 2024.1 base. Bundled JDK 17; minimum Gradle 8.7; minimum AGP 8.5.
Gemini in Android Studio shipped as the successor to Studio Bot — AI-assisted code completion and chat, requires Google sign-in.
Koala Feature Drop: 2024.1.2, Aug 2024. Added significant Compose Preview improvements, rolled the K2 compiler integration further forward, and raised the line’s AGP ceiling to 8.6 — which is what makes the Koala line the Play Store floor.
The last Studio Stable line on the JDK-17 ramp; Ladybug shifts to JDK 21.

Studio

Jellyfish

2023.3.1 · Apr 2024

8.4

8.6

1.9.0+

17 bundled

Studio Bot rebranded to Gemini. Wear OS support polish.

IntelliJ 2023.3 base. Minimum Gradle 8.6; minimum AGP 8.4.
Studio Bot evolves toward the Gemini-in-Android-Studio rebrand that finalizes in Koala.
Wear OS run/debug support refined; emulator pairing flow streamlined.

Studio

Iguana

2023.2.1 · Feb 2024

8.3

8.4

1.8.20+

17 bundled

App Quality Insights for Crashlytics-with-line-numbers. Version Catalog UI.

IntelliJ 2023.2 base. Minimum Gradle 8.4; minimum AGP 8.3.
App Quality Insights surfaces Crashlytics issues with deep-links into the offending source line; reduces the “copy stack trace, hunt down line” loop.
Version Catalog UI makes Gradle’s libs.versions.toml approach visible in Studio rather than only in the file.

Studio

Hedgehog

2023.1.1 · Nov 2023

8.2

1.8.10+

17 bundled

Studio Bot launches (later Gemini). Power Profiler. Espresso Device API.

IntelliJ 2023.1 base. Minimum Gradle 8.2; minimum AGP 8.2.
Studio Bot debuts — Google’s in-IDE AI assistant, US-only at launch; later rebrands to Gemini in Android Studio.
Power Profiler shows on-device power consumption during sessions.
Espresso Device API adds programmatic device-state changes (rotation, fold) to instrumented tests.

Studio

Giraffe

2022.3.1 · Jul 2023

8.1

8.0

1.8.0+

17 bundled

Live Edit for Compose. Gradle Kotlin DSL becomes the default in new projects.

IntelliJ 2022.3 base. Minimum Gradle 8.0; minimum AGP 8.1.
Live Edit for Compose lands — edit a composable, see it update in the running app without re-deploy.
New-project wizard now defaults to Gradle Kotlin DSL (build.gradle.kts) over Groovy.
SDK Upgrade Assistant added to help with target-SDK migrations.

Studio

Flamingo

2022.2.1 · Apr 2023

8.0

1.7.20+

17 bundled

JDK shifts from 11 to 17. AGP 8.0 baseline. The first big upgrade-pain wave of the animal era.

Bundled JDK jumps from 11 to 17. AGP 8.0 requires JDK 17 to run Gradle; projects that pinned to JDK 11 had to upgrade.
AGP 8.0 also flipped non-transitive R classes on by default and removed several long-deprecated DSL surfaces.
IntelliJ 2022.2 base. Minimum Gradle 8.0.
Themed app icons lint check; Compose animation preview improvements.
The single most upgrade-painful Studio release between Arctic Fox and Ladybug; the JDK-17 transition broke Gradle scripts that referenced removed Java 11 APIs.

Studio

Electric Eel

2022.1.1 · Jan 2023

7.4

7.5

1.7.10+

11 bundled

Resizable Emulator. Visual Linting. App Quality Insights launches.

IntelliJ 2022.1 base. Minimum Gradle 7.5; minimum AGP 7.4. Bundled JDK 11.
Resizable Emulator lets one AVD simulate phone, foldable, tablet, and desktop form factors.
Visual Linting flags layout issues at design time across screen sizes.
App Quality Insights ships in v1, surfacing Firebase Crashlytics in Studio.
Last Studio line on the JDK-11 ramp; Flamingo shifts to JDK 17.

Studio

Dolphin

2021.3.1 · Sep 2022

7.3

7.4

1.7.0+

11 bundled

Wear OS emulator pairing. Compose Animation Coordinator.

IntelliJ 2021.3 base. Minimum Gradle 7.4; minimum AGP 7.3.
Wear OS emulator pairing with phone emulator for paired-device debugging.
Compose Animation Coordinator adds inspect-and-scrub UI for Compose animations.

Studio

Chipmunk

2021.2.1 · May 2022

7.2

7.3.3

1.6.21+

11 bundled

Apple Silicon native build (arm64 DMG). Compose Preview live edit (literals).

IntelliJ 2021.2 base. Minimum Gradle 7.3.3; minimum AGP 7.2.
Apple Silicon (arm64) native macOS build ships alongside the Intel build.
Compose Live Edit of literals lands in preview — edit a string or color, see it in the running app.

Studio

Bumblebee

2021.1.1 · Jan 2022

7.1

7.2

1.5.20+

11 bundled

Compose Layout Inspector. Device mirroring (preview).

IntelliJ 2021.1 base. Minimum Gradle 7.2; minimum AGP 7.1.
Layout Inspector for Jetpack Compose hierarchies (the View-system equivalent had existed for years).
Wireless ADB pairing improvements; physical device mirroring lands in preview.

Studio

Arctic Fox

2020.3.1 · Jul 2021

7.0

7.0.2

1.5.20+

11 bundled

First animal codename. New YYYY.N.P versioning aligned with IntelliJ. Bundled JDK 11.

Versioning scheme overhaul. Drops Studio’s sequential 1.x/2.x/3.x/4.x line. New version numbers track the IntelliJ Platform release they’re built on (YYYY.N.P where YYYY is the IntelliJ year, N is the IntelliJ minor, P is the Studio patch). Codenames are alphabetical animals starting with A.
Bundled JDK 11. Predecessors (Studio 4.2 and earlier) bundled JDK 8.
AGP 7.0 baseline; minimum Gradle 7.0.2.
Background Task Inspector ships; non-transitive R classes preview.
The intent of the renaming was to make the Studio ↔ IntelliJ relationship visible. The animal names give each release a memorable handle; the numeric scheme makes the IntelliJ base version explicit.

Above this line: the Animal codename era — alphabetical animal codenames + IntelliJ-aligned YYYY.N.P versioning, July 2021 onward. Below: the Sequential era — sequential major.minor numbering, Studio 1.0 (Dec 2014) through 4.2 (May 2021), bundled JDK 8.

Studio

Studio 4.2

May 2021

4.2

6.7.1

1.4.32+

8 bundled

Last sequential-numeric Stable. Database Inspector improvements.

IntelliJ 2020.3 base. Minimum Gradle 6.7.1; AGP 4.2.
Database Inspector improvements; offline mode for indexing.
The last release on the sequential numbering before Arctic Fox shifted to YYYY.N.P.

Studio

Studio 4.1

Oct 2020

4.1

6.5

1.4.0+

8 bundled

Database Inspector. Custom view inspection.

IntelliJ 2020.1 base. AGP 4.1; minimum Gradle 6.5.
Database Inspector ships v1 for live inspection of Room / SQLite databases on running apps.
TensorFlow Lite Model Binding integration.

Studio

Studio 4.0

May 2020

4.0

6.1.1

1.3.72+

8 bundled

Motion Editor. Build Speed Window. Java 8 desugaring expanded.

IntelliJ 2019.3 base. AGP 4.0; minimum Gradle 6.1.1.
Motion Editor for MotionLayout animations.
Build Speed Window surfaces Gradle bottlenecks.
D8 desugaring expanded to support Java 8+ APIs (java.time, streams) on lower API levels.

Studio

Studio 3.6

Feb 2020

3.6

5.6.4

1.3.40+

8 bundled

View Binding generally available. Split-screen design editor.

AGP 3.6; minimum Gradle 5.6.4.
View Binding lands as a type-safe alternative to findViewById; eventually supersedes Kotlin synthetics.
Split-screen design + code editor for layouts.

Studio

Studio 3.5

Aug 2019

3.5

5.4.1

1.3.0+

8 bundled

Project Marble. Apply Changes replaces Instant Run.

The Project Marble release: a deliberate full-cycle pause on new features, focused entirely on stability, memory, and editor responsiveness. Widely cited as the moment Studio became reliable enough to use full-time without crashing.
AGP 3.5; minimum Gradle 5.4.1.
Apply Changes ships, replacing the long-troubled Instant Run from Studio 2.0.

Studio

Studio 3.4

Apr 2019

3.4

5.1.1

1.3.0+

8 bundled

Resource Manager. R8 default replacing Proguard.

AGP 3.4; minimum Gradle 5.1.1.
R8 ships as the default code shrinker and obfuscator, replacing Proguard.
Resource Manager UI lands.

Studio

Studio 3.3

Jan 2019

3.3

4.10.1

1.3.0+

8 bundled

Navigation editor stable. C++ build improvements.

AGP 3.3; minimum Gradle 4.10.1.
Navigation editor for Jetpack Navigation graphs becomes stable.

Studio

Studio 3.2

Sep 2018

3.2

4.6

1.2.0+

8 bundled

Android App Bundle (AAB) ships. Energy Profiler.

AGP 3.2; minimum Gradle 4.6.
Android App Bundle (.aab) ships as the new packaging format for Play; eventually replaces APK as the required upload format for new apps in 2021.
Energy Profiler ships in the Android Profiler suite.

Studio

Studio 3.1

Mar 2018

3.1

4.4

1.2.0+

8 bundled

D8 dexer default. Kotlin lint checks.

AGP 3.1; minimum Gradle 4.4.
D8 replaces DX as the default dexer; faster, smaller output.
Kotlin lint checks integrated.

Studio

Studio 3.0

Oct 2017

3.0

4.1

1.1.4-3+

8 bundled

Kotlin first-class. AGP 3.0 introduces the implementation / api dependency split.

Kotlin first-class support. Following Google’s I/O 2017 announcement (May 2017), Kotlin ships as a fully supported Android language with templates, code completion, and lint checks. No plugin install required. (Cross-link: Kotlin Versions.)
AGP 3.0 dependency-config split. The legacy compile configuration was deprecated in favor of implementation (no transitive leak) and api (transitive). Forced large refactors across multi-module projects.
Minimum Gradle 4.1.
Java 8 language features (lambdas, default interface methods) became available.

Studio

Studio 2.3

Mar 2017

2.3

3.3

1.0.5+

8 bundled

App Links assistant. Constraint Layout 1.0 stable.

AGP 2.3; minimum Gradle 3.3.
ConstraintLayout 1.0 ships stable as the recommended layout.

Studio

Studio 2.2

Sep 2016

2.2

2.14.1

—

8 bundled

Layout Inspector. Espresso Test Recorder. APK Analyzer.

AGP 2.2; minimum Gradle 2.14.1.
Layout Inspector lands; Espresso Test Recorder ships; APK Analyzer ships.
Kotlin support is still via the JetBrains Kotlin plugin at this stage; first-class support arrives with Studio 3.0 (Oct 2017).

Studio

Studio 2.0 / 2.1

Apr 2016

2.0 / 2.1

2.10 / 2.14

—

8 bundled

Instant Run. Faster emulator. GPU profiler.

AGP 2.0 / 2.1; minimum Gradle 2.10 / 2.14.
Instant Run ships — the long-troubled hot-swap-changes-into-running-app feature. Replaced by Apply Changes in Studio 3.5.
New emulator with significantly faster boot and runtime; GPU profiler.

Studio

Studio 1.0 – 1.5

Dec 2014 – Nov 2015

1.0 – 1.5

2.2 – 2.8

—

8 bundled

First Stable. Replaces Eclipse + ADT. IntelliJ Community base.

Studio 1.0 ships December 2014 as the official Android IDE, replacing Eclipse + the Android Developer Tools (ADT) plugin that had been the supported toolchain since 2007.
Built on the IntelliJ IDEA Community Edition platform from JetBrains. The relationship has held ever since: every Studio release tracks an IntelliJ Platform base.
AGP 1.x; Gradle 2.2 onward; bundled JDK 8.
Eclipse ADT was officially deprecated by Google in 2015 (final release December 2015) and removed from the Android tooling pipeline by 2017.
Original Google I/O announcement was at I/O 2013 (May 2013); the 18-month gap to Stable 1.0 was the migration runway off Eclipse.

Each row anchors as #<codename> for animal-era releases (e.g. #hedgehog, #flamingo) and #studio-N-M for sequential-era releases (e.g. #studio-3-0). Each cell in the AGP, Gradle, and Kotlin (KGP) columns is the minimum supported version for that Studio — the floor. Higher versions in the same major line generally work; lower versions don’t. The intent is to answer “upgrade as little as possible”: when something forces you to bump one product, this matrix tells you the smallest matching bumps the others need. The row marked with the amber left edge and the Play Store Min badge is the additional Play Store submission floor — the lowest Studio that produces a Play Store-compliant build for new submissions today. Anything below the line can’t compile against the currently-required Android target SDK. Confirm exact pinning against developer.android.com/studio/releases, the AGP release notes, and Google’s target-SDK requirements; the matrix above is refreshed quarterly with a tighter sub-cadence on the Play Store floor.

Which JDK actually runs your build?

The single biggest source of upgrade confusion: there are three different JDKs in play in any Android Studio project, and which one is “your JDK” depends on the question. JAVA_HOME alone won’t tell you. Installing JDK 21 system-wide does not, by itself, change the JDK Studio uses. Here’s the actual layout:

JDK #1

The JDK Studio itself runs on (bundled)

Each Studio release ships with a JDK bundled inside the app — that’s the JVM the Studio process runs on. You don’t pick this; it’s baked into the Studio download. The Bundled JDK column in the matrix above is this one. By default, Gradle invocations from inside Studio also use this same bundled JDK, which is why “but I have JDK 21 installed system-wide” doesn’t change anything: Studio is using its own JDK, not yours.

JDK #2

The JDK Gradle runs on (Project Structure → Gradle JDK)

The JDK Gradle uses to execute build scripts. Defaults to JDK #1 (Studio’s bundled JDK), but is overridable per-project at File → Project Structure → SDK Location → Gradle Settings → Gradle JDK, or globally with org.gradle.java.home=/path/to/jdk in gradle.properties.

AGP’s minimum supported JDK — JDK 17 across the entire AGP 8.x and 9.x line — applies to this JDK, the one Gradle runs on. Note the common confusion: Studio bundles JDK 21 from Ladybug onward, so JDK #1 (and therefore JDK #2 by default) is 21 — but AGP’s actual floor is still JDK 17. The minimum is a floor, not a target: AGP 8.x / 9.x run fine on JDK 17 or JDK 21, but not on JDK 11. Gradle itself has since caught up to the same number — the Gradle 9 line requires a JVM between 17 and 26 to run at all — so on a current toolchain the two floors coincide, where for most of the AGP 8.x era AGP was the stricter of the two. When an AGP upgrade complains about JDK version, you have two options: update Studio (which updates JDK #1, which is JDK #2 by default), or point JDK #2 at a JDK install that meets the floor — whichever is the smaller move for your team.

JDK #3

The JDK target your code compiles against (Java toolchain)

The JDK version your application code is compiled with — independent of JDK #1 and JDK #2. Set in your build.gradle / build.gradle.kts:

// build.gradle.kts — Kotlin DSL
kotlin {
  jvmToolchain(17)
}

// or, in the java {} block
java {
  toolchain {
    languageVersion = JavaLanguageVersion.of(17)
  }
}

This is the right place to pin the Java compilation level for your app, and it’s the JDK Gradle will fork to do compilation. It’s independent of JDK #2: you can run Gradle on JDK 21 (because that’s what your Studio bundles) and still compile your app against JDK 17 source/target via the toolchain. This is what most teams want — pin the toolchain to the lowest JDK your app actually needs to support, regardless of which JDK Studio ships with this year.

Rule of thumb when upgrading. Update Studio only as far as you need to satisfy whatever forced your hand — that brings JDK #1 (and by default JDK #2) along automatically. Leave JDK #3 (the toolchain) where it is unless your app actually needs a higher Java language level. JAVA_HOME on your shell affects neither in practice — Studio’s launcher only falls back to it if the bundled JetBrains Runtime is missing, and Gradle reads it when you invoke Gradle from a terminal (Studio’s own terminal included), not when you press Studio’s run buttons, which use the JDK set in Studio’s settings.

The 2013 announcement, the 2014 Stable, and the Eclipse-ADT exit

Android Studio was announced at Google I/O 2013 in May 2013, as a preview-quality replacement for the Eclipse + Android Developer Tools (ADT) plugin that had been the official Android IDE since the platform’s earliest days. Eclipse ADT had served Android well in its first five years (2007–2012) but had structural problems that the team had given up trying to fix from within: slow project sync, fragile XML editors, an obstinate Ant-derived build system that didn’t play well with the rest of the JVM ecosystem, and a long string of integration headaches against new platform APIs.

The replacement bet was that the IntelliJ IDEA Community Edition platform from JetBrains was a better foundation. IntelliJ’s indexer was significantly faster, its editor model was richer, and its plugin architecture was more amenable to the Android-specific surface area Google needed (layout editors, ADB integration, emulator management, profilers). Building Studio on top of IntelliJ Community meant getting a decade of editor work for free and partnering with JetBrains, which has produced both Studio’s underlying platform and Kotlin (the language Studio went on to first-class in 2017).

Studio 1.0 went GA on December 8, 2014, eighteen months after the I/O reveal. The migration runway off Eclipse ADT was bumpy: many projects had to convert their Ant-style structure into Gradle, learn the new build.gradle DSL, and re-resolve dependencies. Eclipse ADT was officially deprecated in mid-2015 (final release in December 2015) and the toolchain assets removed from the Android SDK pipeline by 2017. By 2018, building Android apps in Eclipse was dead.

The IntelliJ relationship and the 2021 versioning shift

Every Android Studio release is built on a specific IntelliJ Platform base. Studio inherits IntelliJ’s editor, code-intelligence engine, indexer, refactoring, debugger UI, and most of the language plugin ecosystem — layered with Android-specific surfaces (layout editors, ADB integration, the Profiler suite, Compose tooling, the Gradle plugins the Android team maintains, etc.). The relationship is open and reciprocal: IntelliJ ships features, Studio absorbs them; Studio occasionally upstreams improvements that benefit the broader IntelliJ user base.

The IntelliJ Platform is a JetBrains product — an open-source application substrate (Apache 2.0) that other vendors license to build IDEs on, with Android Studio the most prominent external example.

Until Arctic Fox (July 2021), Studio used a sequential major.minor numbering scheme — 1.0 through 4.2 — that was independent of the IntelliJ base it was built on. This obscured an important fact: which IntelliJ version your Studio was built on materially affected which features and bug fixes you got. Knowing “Studio 4.1” didn’t tell you which IntelliJ release it was tracking.

Arctic Fox introduced the YYYY.N.P versioning aligned with IntelliJ’s own release cycle: 2020.3.1 means “based on IntelliJ 2020.3, the first feature release on that base, with patch level 1.” The alphabetical animal codenames give each release a memorable handle (Arctic Fox, Bumblebee, Chipmunk, ...) so humans don’t need to recite four-part numbers when discussing which Studio they’re on. The renaming was contentious at the time — it broke a decade of mental shorthand — but has aged well; the IntelliJ-base information is now visible at a glance.

The Studio × AGP × Gradle coupling — why upgrading is hard

The coupling that makes this page’s matrix necessary is structural, not incidental. The Android build is Gradle-based; the Android-specific build logic lives in the Android Gradle Plugin (AGP), a Google-maintained Gradle plugin separate from Gradle itself. Studio integrates with both by talking to Gradle through Gradle’s tooling API and to AGP through plugin metadata.

Three independent products, three independent release cadences, three independent compatibility matrices. AGP is updated alongside Studio; Gradle ships its own releases that AGP picks up some-but-not-all of; Studio binds to a specific minimum AGP. When any one of the three moves, the other two often have to follow. The error messages when they’re out of sync are notoriously poor — “Gradle sync failed” with no useful diagnosis, “Plugin requires Gradle X.Y or newer” with no path forward, “AGP X requires Studio Y” in some cases — and the canonical compatibility tables are scattered across developer.android.com/studio/releases and the AGP release notes.

Add Kotlin (the Kotlin Gradle Plugin pins both a minimum Gradle and a minimum AGP) and the JDK (Gradle has a minimum JDK to run, AGP has its own, and Studio bundles a JDK that doubles as the default — AGP was the stricter of the two floors through the 8.x era, and Gradle 9 has since pulled level at JDK 17), and the matrix becomes five-dimensional. The matrix above is the answer — and the framing matters: every cell is a floor, the lowest version that still works, not a recommendation. The right move when something forces an upgrade is usually to satisfy the floor and stop, rather than chase the latest of everything. The Apple-side counterpart is Xcode: same cascade pattern (IDE pins minimum macOS and bundles Swift; AGP’s role is played by the Xcode SDK; Google Play Store’s target-SDK floor maps to the App Store submission floor) but with macOS upgrades themselves often the binding constraint, since older Macs can’t run the latest macOS.

Kotlin first-class — Google I/O 2017

At Google I/O 2017 (May 2017), Google announced first-class support for Kotlin as an Android language. Studio 3.0 (October 2017) shipped that support: Kotlin templates in the new-project wizard, code completion, lint checks, refactoring across Kotlin and Java sources, and removal of the “install the Kotlin plugin first” step that had been the friction for early Kotlin adopters since 2014.

The decision was strategically driven by two pressures. Oracle v. Google — the eleven-year API copyright case over Android’s reimplementation of 37 Java SE packages — was still unresolved at I/O 2017 (it would not reach the Supreme Court for fair-use vindication until April 2021). Reducing structural reliance on Java APIs was a hedge. Kotlin’s growing popularity in the developer community, JetBrains’ willingness to evolve the language collaboratively with Google, and Kotlin’s genuine technical merits (null-safety, coroutines, interop with existing Java codebases, a saner type system) made it the obvious successor.

In May 2019, Google announced Kotlin-first — the official recommendation for new Android development. Java is still supported, but new platform APIs are designed Kotlin-first (with Java compatibility added second), most new Jetpack libraries ship Kotlin-only, and the Android Developers documentation defaults to Kotlin code samples. The Kotlin Gradle Plugin compatibility column in the matrix above tracks this dependency.

Jetpack Compose tooling

Jetpack Compose — Android’s Kotlin-based declarative UI toolkit, modeled on React and SwiftUI — reached stable in July 2021, alongside Studio Arctic Fox. Studio shipped Compose-aware tooling at the same time: an interactive Preview pane that renders composables without a device, a Layout Inspector that walks Compose hierarchies, code completion that understands the @Composable modifier, and (in later releases) Live Edit and the Animation Coordinator.

The Compose tooling story has been a steady cadence of refinement across the animal-codename releases. Bumblebee added the Layout Inspector for Compose. Chipmunk added Live Edit of literals. Giraffe added full Live Edit of composables. Hedgehog added Espresso Device API. Koala and Ladybug refined Compose Preview, Live Edit, and the Inspector further. Each release has chipped at the gap between “edit a composable, recompile” and “edit a composable, see it instantly.”

Studio Bot → Gemini in Android Studio

Google announced Studio Bot at I/O 2023 as Studio’s AI assistant, US-only at launch and shipping with Hedgehog (November 2023). Studio Bot offered code completion, code generation, and an in-IDE chat trained on Android-specific knowledge. Quality was uneven at launch but improved rapidly through Iguana and Jellyfish.

At I/O 2024, Google rebranded Studio Bot to Gemini in Android Studio, aligning the in-IDE assistant with Google’s broader Gemini model family. Koala (June 2024) shipped that rebrand. Subsequent releases have added refactoring suggestions, multi-file context, Crashlytics-aware debugging suggestions, and richer code-review pass-throughs. The feature requires a Google sign-in and respects the standard Gemini usage policies; it is opt-in.

The two years since the rebrand have moved the assistant from completion to agent, and then loosened the “Gemini” in its name. Agent Mode — multi-stage tasks spanning several files, with a plan-and-iterate flow — debuted in the Narwhal Feature Drop (July 2025) and became the default invocation in Narwhal 4 (October 2025), at which point the old Chat tab was renamed Ask. The Otter 3 Feature Drop (January 2026) then decoupled the feature from the model: Studio’s AI features can be driven by any LLM via a bring-your-own-key configuration, so the branding now describes the default rather than the only option. Otter also added the ability to connect to remote MCP servers, which Quail 3 (July 2026) turned into an in-IDE MCP Marketplace alongside a /plan command and an agent that resolves merge conflicts. Quail 4 (September 2026) pushed the decoupling to its end point and the agent past the editor at the same time: an integrated runtime now executes Gemma 4 locally, so the assistant can run with no hosted model behind it at all, and the agent can enable and configure Firebase Authentication and Cloud Firestore from the chat window rather than only writing code. The through-line is the same one the Compose tooling shows: each release narrows the gap between describing a change and having it made.

Coda — the Eclipse ADT footnote

Eclipse + ADT was the official Android toolchain from 2007 through 2014. ADT (Android Developer Tools) was the Eclipse plugin that surfaced Android-specific functionality — the manifest editor, layout XML editor, ADB integration, and the build orchestration over Apache Ant. The Studio 1.0 announcement formally deprecated ADT in 2014; final ADT release was December 2015 (ADT 23.0.7), and Google removed the Eclipse-targeted SDK assets from the toolchain pipeline by 2017. The migration tooling Google shipped in early Studio releases (the “Import from Eclipse” wizard) was a bridge for the long tail of teams still on ADT; by the late 2010s, building Android apps in Eclipse had effectively ended.