Google ships Android Studio as one installer per platform, separate builds for Windows, macOS, Linux, and ChromeOS, and getting started is mostly a matter of grabbing the right one.
It bundles the Android SDK, an emulator, and a Gradle-based build system into that single package, which is the whole point of using it. You’re not assembling a compiler, a device simulator, and a build tool from three separate downloads.
It’s free, distributed by Google under the Android Software Development Kit License, no fee attached.
Size-wise, the Windows installer runs about 1.5 GB on its own, per Google’s own download page (2026). macOS and Linux land close to that too, somewhere between 1.5 and 1.6 GB, and that’s before the setup wizard pulls the Android SDK down on top of it.
What Is Android Studio?
Google built it on top of IntelliJ IDEA, the platform JetBrains makes, then layered the Android SDK, an emulator, and a Gradle-based build system over that foundation.
That combination is the actual reason people use it for Android development instead of piecing tools together themselves. One download replaces a compiler, a device simulator, and a build tool you’d otherwise wire together by hand.
Google maintains the tool and ships it at no cost, under that same Android Software Development Kit License.
A few numbers are worth pinning down here. The current stable release is Android Studio Quail 4, version 2026.1.4 Patch 1 (Google, developer.android.com), built on IntelliJ IDEA under license from JetBrains. New projects default to Kotlin now, a language that shows up in over 95% of the top 1,000 Play Store apps (Google, developer.android.com). Cloud features like Gemini in Android Studio and Firebase Crashlytics only stay active on the current stable channel plus roughly the last 10 months of major releases (Google, developer.android.com), so an older install can quietly lose access to those without anything looking broken.
It’s also not the same thing as the Android SDK on its own. The SDK is one ingredient inside Android Studio, and command-line-only setups can install just that piece without the full editor.
Android Studio System Requirements
Android Studio needs at least 8 GB of RAM and 8 GB of free disk space on every supported operating system, more once the emulator joins in.
Google publishes separate minimum and recommended tiers for Windows, macOS, Linux, and ChromeOS, and the recommended tier is the one that actually keeps Gradle syncs from crawling.
| OS | Minimum | CPU | Recommended |
|---|---|---|---|
| Windows | 8 GB RAM, 8 GB disk (16 GB with emulator) | x86\_64, 2nd-gen Intel Core or AMD with Hypervisor support | 16 GB+ RAM, SSD with 32 GB free |
| macOS | 8 GB RAM, 8 GB disk (16 GB with emulator) | Apple M1 or 6th-gen Intel Core or newer | 32 GB RAM, latest Apple Silicon chip |
| Linux | 8 GB RAM, 8 GB disk | x86\_64, glibc 2.31 or later | 16 GB+ RAM, SSD |
| ChromeOS | Same baseline as Linux | Runs the Linux build inside a container | ChromeOS device with Linux support enabled |
Source: Google’s own install documentation (developer.android.com).
Most of that space disappears fast, and it helps to know where it goes. The IDE itself, plus its bundled runtime, eats up a few gigabytes before you’ve done anything. Emulator system images add more on top of that, and most projects end up pulling down two or three of them. Then there’s Gradle’s dependency cache, which just keeps growing project by project, and it’s the real reason Google recommends an SSD with 32 GB or more free rather than treating that 8 GB minimum as an actual plan.
ARM-based Linux machines aren’t supported for Android Studio itself, even though ARM Android devices run fine as emulator targets.
Which Installation Method Should You Use?
Most developers should use the official installer from Google’s own download page, since it’s the version every tutorial and Stack Overflow answer assumes you have.
A few other paths exist too, mainly for people who already manage several JetBrains tools or just prefer a package manager: JetBrains Toolbox, Homebrew, and the Snap Store.
| Method | Best for | Trade-off |
|---|---|---|
| Official installer | First-time setup, most Windows and macOS users | Manual updates unless you check for them |
| JetBrains Toolbox | Developers running several JetBrains IDEs | One more app to keep open |
| Homebrew | macOS and Linux users who script their setup | Depends on Homebrew staying current |
| Snap Store | Ubuntu and other snap-enabled Linux distros | Slower startup than a native package |
Official Installer
This is the .exe, .dmg, or .tar.gz file Google hosts directly, and it’s what the setup wizard in the next section walks through.
You don’t need an account or a package manager for any of it. The version number matches what’s listed in Google’s own release notes too, and on Windows and macOS you get an uninstaller bundled in as well.
Pick this one unless you have a specific reason not to.
JetBrains Toolbox
It handles updates for Android Studio right alongside IntelliJ IDEA, PyCharm, and whatever else you’ve got from JetBrains, all through one central tool. You can also roll back to an older Android Studio build without digging through an archive page if you ever need to.
Toolbox itself sits in the system tray and checks for updates on its own schedule, which some developers find convenient and others find noisy.
Homebrew
On macOS and Linux, a single terminal command pulls in Android Studio through Homebrew’s cask system.
It suits developers who already script their machine setup end to end, since the same Brewfile that installs a code editor can install the IDE too.
brew install --cask android-studio
Snap Store
Snap packages sandbox the application, trading a slightly slower cold start for tighter isolation from the rest of the system.
Ubuntu ships with snap support built in, so there’s no extra setup on that front, and updates install automatically in the background without you having to think about it.
One catch here, a build that worked yesterday can change under you without warning, since snap updates don’t wait around for your permission.
How to Install Android Studio Step by Step
The process looks almost identical no matter which operating system you’re on, from downloading the file to opening the IDE for the first time. Everything after that first step runs through the same setup wizard.
- Grab the installer that matches your OS from Google’s official page: .exe for Windows, .dmg for macOS, .tar.gz for Linux, .deb for ChromeOS.
- Open it and accept the Android Software Development Kit License Agreement when the welcome screen asks.
- Pick an install type, Standard or Custom, when the wizard gets there.
- Let it download the Android SDK components and whatever emulator system images it recommends.
- Launch Android Studio and check that the welcome screen loads without throwing an error.
On Windows, the .exe path is simpler than the .zip path, since the .zip route means copying the android-studio folder into Program Files yourself.
On macOS, dragging the app into the Applications folder from the mounted .dmg is the entire installation.
Standard vs Custom Installation
Standard grabs a sensible default set of SDK components and mostly stays out of your way. Custom is slower on purpose, it stops at every screen so you can choose specific API levels, skip components you already have, or point the wizard at an SDK folder you’re already using.
| Install type | Setup time | Best for |
|---|---|---|
| Standard | Fastest, one pass through the wizard | First install, most personal machines |
| Custom | Slower, several decision screens | Shared machines, existing SDK reuse, disk-limited setups |
Pick Standard the first time you install Android Studio. Switch to Custom later, once you actually know which API levels your projects target.
Configuring the SDK Manager and the Bundled JDK
The SDK Manager is the screen inside Android Studio where you add, update, or remove Android SDK components once the initial setup wizard finishes.
Two packages matter more than the rest: SDK Platform-Tools and SDK Build-Tools.
SDK Platform-Tools and Build-Tools
Platform-Tools installs Android Debug Bridge, the command that connects Android Studio to emulators and physical devices. Build-Tools handles the actual compiling, packaging, and signing of whatever APK or AAB your project spits out. And if you’re setting up a CI server that never opens the actual editor, there’s a separate command-line tools package for exactly that case.
The Android SDK tools available through this manager get their own update cycle, separate from Android Studio’s own release schedule.
Skipping a Build-Tools update usually surfaces as a Gradle sync error the next time you open an unrelated project.
Bundled JDK and Environment Variables
Android Studio ships its own Java runtime, called the JetBrains Runtime, so a separate JDK install isn’t required just to open the IDE.
Recent Android Studio releases bundle a JetBrains Runtime built on JDK 21, a long-term support release (Google, developer.android.com).
You only need to set JAVA\_HOME when a command-line build or some other tool insists on its own JDK path, the IDE itself doesn’t need it.
Windows and Linux installs add Android Studio’s bin folder to PATH automatically. macOS users running it through Homebrew sometimes have to add it by hand.
Projects that declare a specific Java version in build.gradle can point Gradle at a different JDK than the one running the IDE itself, without breaking either one.
How Do You Set Up an Android Virtual Device?
The AVD Manager is where virtual Android phones and tablets get created, so you can test without owning the physical hardware.
Open it from Tools > Device Manager, then click Create Device to start.
Choosing a System Image and API Level
Every virtual device needs a system image, a snapshot of a specific Android version, paired with an API level.
Match the API level to your project’s target SDK and minimum SDK, not just whatever’s newest.
Target SDK marks the API level your app is actually built and tested against. Minimum SDK is a separate number, the oldest Android version you’re still committed to supporting. Recent Android Studio releases have also started adding ready-made device definitions, like the Pixel 10 series, straight into the picker (Google, developer.android.com), which saves you from hand-configuring specs that used to take a few extra clicks.
Enabling Hardware Acceleration by Operating System
An emulator without hardware acceleration boots slowly and drags through every interaction after that.
| OS | Acceleration backend | Notes |
|---|---|---|
| Windows | Windows Hypervisor Platform | Enable in Windows Features, not just the BIOS |
| macOS | Apple Hypervisor Framework | Built in on Apple Silicon, no setup needed |
| Linux | KVM | Requires the user account to be in the kvm group |
Older setups relied on Intel HAXM for acceleration on Intel chips. Current installs use the operating system’s own hypervisor instead, so HAXM no longer ships by default.
Testing on a Physical Device Instead
A physical phone skips the emulator step altogether. You get real sensor data and a real camera, plus performance numbers that actually reflect the hardware instead of a simulated approximation.
Turn on Developer Options and USB debugging on the device, then approve the RSA fingerprint prompt that appears the first time you connect it.
Details on connecting a phone to Android Studio over USB cover driver issues that trip up Windows users more often than macOS or Linux ones.
Once connected, the device shows up in the same run target dropdown as any Android Studio emulator instance, so switching between them takes one click.
Creating and Running Your First Project
Android Studio’s New Project wizard shows up the moment setup finishes, and it’s the fastest way to confirm the install actually works.
Pick the Empty Activity template, since it creates the smallest possible working app.
That template defaults to Kotlin as the project language. It also pulls in Jetpack Compose, Google’s declarative toolkit for building screens in Kotlin, for the UI layer, and it wires up a single Activity along with a build.gradle file already pointed at the SDK you configured earlier.
Clicking Finish triggers the first Gradle sync in Android Studio, which downloads dependencies and can take several minutes depending on your connection.
A slow first sync is normal. Every sync after that reuses the cache and finishes much faster.
Swiggy, the Indian food delivery company, is a decent example of what that setup scales to. The company rewrote 74% of its Android app in Kotlin and saw crashes drop by roughly 50% after making the switch (Google, developer.android.com), and that’s the exact same language and build system your fresh Empty Activity project starts with by default.
Once the sync finishes, press the green Run button and pick a target, either the virtual device from the previous section or a connected phone.
A working build shows the default “Hello Android” screen. If it doesn’t, the next two sections cover what usually broke and how to fix it.
Keep a Kotlin cheat sheet nearby while you explore the generated code, since the template leans on syntax that looks unfamiliar if you’re coming from Java.
When Installing Android Studio Does Not Apply
Android Studio isn’t the right install for every situation, even within Android development itself. A handful of cases come up often enough to name directly.
| Situation | Why the full IDE fails | Better fit |
|---|---|---|
| Machine under the RAM/disk minimums | The setup wizard hangs, or the Gradle daemon throws an out-of-memory error | Upgrade the hardware first, or use a cloud-hosted build agent |
| CI and build servers | No one ever opens the editor UI on a headless runner | sdkmanager and the command-line tools package alone |
| Windows on ARM64 (Copilot+ PCs) | The emulator’s Windows Hypervisor Platform acceleration ships for x64 hosts only, per Google’s own issue tracker | A physical Android device connected over USB instead |
| Entry-level Chromebooks | Play Store app support and enough RAM headroom rarely land on the same low-cost hardware | A cloud IDE, or a second machine for local builds |
Headless builds are common practice, not an edge case.
The Android Open Source Project itself compiles entirely from the command line, without Android Studio anywhere in the pipeline, since building the operating system never touches the SDK Manager.
A CI runner only needs the command-line tools package and a pinned Gradle version, both installable with a few shell commands and no graphical wizard at all.
None of this makes Android Studio optional for day-to-day app development. It just means the full IDE is one tool among several, not a requirement for every step of the pipeline.
Fixing Common Android Studio Installation Problems
Most installation problems come down to the same few root causes: a version mismatch, a blocked network path, a corrupted cache, or leftover files from an older install.
| Symptom | Likely cause | Fix |
|---|---|---|
| Gradle sync failed | The project’s Gradle wrapper does not match the required Android Gradle Plugin version | Update the Gradle wrapper to the version the current AGP release notes specify |
| Android Studio won’t open | A corrupted index or config folder carried over from an earlier version | Rename or delete the AndroidStudio config folder, then relaunch |
| Slow right after install | First-time indexing on a large project, or too little RAM for the emulator running alongside it | Let indexing finish once, close the emulator while editing code |
| SDK components won’t download | A corporate proxy or firewall blocks dl.google.com | Set the proxy under Settings, or install the offline SDK package instead |
Gradle sync failed is the single most common error message a fresh install runs into.
Each Android Gradle Plugin release requires a minimum Gradle version, documented on Google’s own Android Gradle plugin release notes page.
A project pinned to an old Gradle wrapper can fail to sync the moment it opens in a newer Android Studio release, well before any code gets touched.
Google tracks confirmed bugs and workarounds on its own Known Issues page, separate from general forum advice.
A fresh install that refuses to launch is usually a leftover settings folder from an old version, not a broken download.
Deleting the IDE’s own config and cache folders, not the SDK folder, resolves most of these without a full reinstall.
Updating and Uninstalling Android Studio
Android Studio checks for updates on its own, and you get to pick which channel delivers them.
Updating Through Release Channels
Each channel trades some stability for access to newer features, and which one fits depends on what you’re actually doing with the install.
| Channel | Update pace | Use case |
|---|---|---|
| Canary | Roughly weekly (Google, developer.android.com) | Trying new features early, not for production work |
| RC | Release candidates based on stable Canary builds | Feedback before a stable release ships |
| Stable | The default channel most installs run | Everyday app development |
Switch channels under File > Settings > Appearance & Behavior > System Settings > Updates, or Android Studio > Check for Updates on macOS.
A closer look at updating Android Studio across channels covers what changes with each switch, beyond just the version number.
There’s one thing worth knowing here. The first time a new major version launches, Android Studio scans for cache, index, and log folders left over from versions it can no longer find, and offers to clear them out through its own Delete Unused Directories dialog (Google, developer.android.com).
Uninstalling on Windows, macOS, and Linux
Removing the application itself rarely removes everything it created.
On Windows, you uninstall through Settings > Apps, but that leaves the .android, .gradle, and AndroidStudio folders sitting under your user profile until you clear them out yourself.
Uninstalling on macOS just means dragging the app from Applications to the Trash. It won’t touch the matching folders under Library/Application Support and Library/Caches though, so those need removing separately if you actually want the space back.
Linux is the messiest of the three in a way, since there’s no single uninstaller. You delete the android-studio directory wherever it was originally unpacked, plus the hidden AndroidStudio and android config folders sitting in your home directory.
The Android SDK folder usually sits outside all three of these paths, so removing Android Studio doesn’t automatically free the space its SDK platforms and system images were using.
For the exact file paths on each platform, a full walkthrough on uninstalling Android Studio covers every folder Google’s own uninstaller leaves behind.
FAQ on How To Install Android Studio
What is the difference between Android Studio and the Android SDK?
Confusing these two costs people time when they’re troubleshooting, so it’s worth being precise. Libraries, platform tools, and system images, the stuff a project actually compiles against, make up the Android SDK. Android Studio wraps an editor, a debugger, and Gradle integration around that SDK, and the SDK installs on its own through command-line tools, skipping the full IDE entirely.
Is Android Studio free to use?
Yes, and there’s no catch. Google distributes it under the Android Software Development Kit License at no cost, for personal and commercial projects alike.
Unlike JetBrains’ paid IntelliJ IDEA Ultimate, the platform it shares code with, Android Studio itself carries no license fee or seat count.
Do you need administrator or root permissions to install Android Studio?
Not necessarily. Windows and Linux both let you unpack the files into a folder you own, skipping admin rights entirely.
Only installing into Program Files on Windows, or a system-wide path on Linux, prompts for elevated permissions.
What Should You Check First When How To Install Android Studio Breaks Down?
When Android Studio breaks during setup, the cause is nearly always the same short list: a mismatched installer checksum, or virtualization that’s still switched off somewhere between the BIOS and the OS.
Machines at the 8 GB RAM minimum satisfy the installer itself, yet that figure sits below the 16 GB Google recommends once the emulator runs alongside the IDE. Installs that finish the wizard cleanly can still stall the instant a virtual device boots, since both now compete for the same memory.
A few checks catch most of these failures before they turn into a full reinstall:
- Match the installer’s checksum before running it
- Confirm virtualization is enabled in Windows Features, not just the BIOS
- Watch memory usage the moment a virtual device boots
Once the emulator boots without stalling, the next step is to use Android Studio day to day, from run configurations to the built-in profiler tools.
- MySQL Cheat Sheet - September 30, 2026
- How to Remove Duplicate Lines in Notepad++ (Sorted or Unsorted) - September 29, 2026
- Should Your Engineering Team Still Own the Marketing Website? - September 29, 2026
