Android Studio is an editor for Android code, and you may own an Android app without ever needing one.
Android Studio is the official integrated development environment for Android apps, and Android Developers uses those words on its own introduction page. It is built on the editor from IntelliJ IDEA, and what it adds on top is a Gradle build system, an emulator, lint checks, test tooling, profilers and NDK support. All of that is for people writing Android source code. If you were handed a React Native and Expo project instead of writing one, the useful question is not how to learn the IDE. It is which of the pieces inside it your project touches, and the answer is usually two of them. Most changes you will make are JavaScript, and a JavaScript change can reach people who already installed the app as over the air updates with no native build in the way.
What follows is what Android Developers says the IDE is for, what is actually inside the download, whether a project you did not write needs any of it, and which of its windows would ever earn their place on your machine. Every claim carries the page it came from and the date it was read.
Start hereThe short version
The download is an IDE wrapped around a set of packages you can get alone.
Two different things arrive when you install Android Studio. One is an editor and a set of inspection windows for Android source code. The other is the Android SDK, which is what actually compiles an app and runs it on a device. Google's command-line tools page, last updated 25 September 2026, says the SDK is composed of multiple packages required for app development, that each one installs either from Android Studio's SDK Manager or from the sdkmanager command-line tool, and that if you are not using Android Studio you can download the command-line tools package instead. The download page carries a Command line tools only section, read on 17 October 2026.
So the real question is never the IDE. It is whether anything on your list compiles the app on your own hardware. React Native answers that on its own setup page: with a React Native framework you do not need to set up Android Studio or Xcode, because the framework takes care of building the native app for you. A generated project is a framework project. The IDE becomes worth installing the day you want to watch the app on a virtual phone or read the native log, and not a day earlier.
What does Android Developers say Android Studio is for?
The Meet Android Studio page, which carries a last updated date of 16 October 2026, gives a one-line definition and then a list. The definition: Android Studio is the official integrated development environment for Android app development, based on the code editor and developer tools from IntelliJ IDEA. The list of what it adds on top is eight items long. A flexible Gradle-based build system. A fast and feature-rich emulator. A unified environment for developing for all Android devices. Live Edit, for updating composables on emulators and physical devices in real time. Code templates and GitHub integration. Testing tools and frameworks. Lint checks for performance, usability and version compatibility problems. C++ and NDK support.
Read that list as somebody who owns an app rather than writes Android code, and it sorts itself quickly. Six of the eight are for authors of Kotlin and Java: templates, tests, lint, the NDK, Live Edit and the unified environment. Two of the eight are the reason anyone else installs it: the build system, because it is what turns a project into something installable, and the emulator, because looking at the app is the point.
The rest of the same page is an inventory of inspection windows: inline debugging, Layout Inspector, performance profilers for memory and CPU and network, heap dumps in Android's HPROF format, the Memory Profiler, code inspections, annotation validation, and the Logcat window, which the page describes as where you view adb output and device log messages. There is also a sign-in, which Google says unlocks tools that need authentication such as Firebase, Android Vitals inside App Quality Insights, and Gemini in Android Studio. None of that is marketing on our part. It is the official feature list, and it is aimed squarely at the person who typed the project.
Android Developers, Meet Android Studio, read 17 October 2026
What is actually inside the download?
Four SDK packages do the work, and Google lists them by name. The Android SDK Command-Line Tools, which hold sdkmanager for installing packages, avdmanager for creating and managing virtual devices from the command line, lint, retrace for decoding an obfuscated stack trace, and apkanalyzer for looking inside a finished build. The SDK Build-Tools, which Google says are required to build Android apps. The SDK Platform Tools, which hold adb, fastboot and logcat, and which Google says you can download on their own as well as from the SDK Manager. And the Android Emulator package, which Google says is required to use the emulator.
Lay that beside the feature list and the IDE stops looking like a prerequisite and starts looking like a front end. Device Manager and avdmanager both create virtual devices. The Logcat window shows what adb is already printing, and Google describes logcat itself as invoked by adb to view app and system logs. The SDK Manager window and the sdkmanager command install the same packages into the same SDK directory. Even the build is explicit about this: Google writes that the Gradle build system runs as an integrated tool from the Android Studio menu and independently from the command line.
Two things the IDE does not bring, which catch people who assumed it was one install. A Java Development Kit and Node are separate, and React Native lists them separately on its setup page. And the platform level your project compiles against is a choice you make inside the SDK Manager, not a default: Expo's emulator page, modification date 16 October 2026, says the Android 16 Baklava SDK is required to compile a React Native app and asks for Android SDK Platform 36, while React Native's own core setup page, last updated 12 August 2026, names Android 15 VanillaIceCream instead. Two first-party pages, two numbers, and neither is wrong about the toolchain it was written for. Take the one belonging to the framework you actually build with, and check the Expo SDK release notes for your version rather than memorising a level.
React Native, Set Up Your Environment, last updated 12 August 2026, read 17 October 2026
Check yours
What you actually need installed
Tick what you are trying to do this week. The answer is a package, a command or nothing at all, more often than it is the whole IDE.
Nothing ticked. If every job on your list is a change to the app's own code, nothing on this page needs to be on your machine.
Do you need it for a project you did not write?
Expo documents three ways to get a project running on an Android device, and names Android Studio in exactly one of them. The first is a sandbox app installed from the Play Store, which asks for nothing from Android on your computer. The second is a development build produced by Expo's hosted builder, which you install from a link or a scanned code. The third is a development build you compile locally, and that one lists Android Studio as a prerequisite, in Expo's words, to compile and run Android projects on your local machine. That page carried a modification date of 17 August 2026 when it was read. One route out of three, and it is the route that compiles on your hardware.
There is a second reason the IDE feels beside the point here, and it is specific to how modern React Native projects are organised. Expo calls it Continuous Native Generation. Its page, modification date 25 September 2026, describes native projects as short-lived and generated only when needed, such as when debugging or building. Running prebuild is what creates the android and ios directories. Those directories are added to the project gitignore automatically for new projects, and the hosted builder runs prebuild itself when they are missing. The same page warns that if you modify the generated directories manually you risk losing your changes the next time you run a clean prebuild, and points at config plugins as the supported way to change native code. So there may be no android folder to open, and the one you can generate is a draft.
Note that this answer is framework-specific rather than universal. An Android app written in Kotlin has no framework standing between it and the toolchain, so the SDK is not optional there and the IDE is where most of that work happens. Weighing Flutter against React Native is partly a question about which toolchain ends up on your laptop, and both of those answers are shorter than the Kotlin one. The honest limit on all of it: the moment a hosted build cannot resolve something, or a native crash needs reading, somebody needs the SDK on a real machine, and the IDE is the shortest route to it.
React Native, Set Up Your Environment, on whether setup is required, read 17 October 2026
Which of its windows would ever earn their place?
Logcat first, because it is the one that answers questions nothing else can. The Android system log carries native crash lines, permission refusals and processes killed for memory, and none of those reach a JavaScript console. Android Studio presents that stream in a window and the SDK gives you the same stream in a terminal through adb. If you install one thing from this page, it is the package that contains adb.
Then the two that look relevant and are not. Layout Inspector is documented as inspecting a Compose layout inside a running app, including how often a composable is recomposed or skipped. Live Edit is documented as updating composables in real time. A generated React Native screen is not built from composables, so neither window is pointed at your screens. Lint has the same shape of problem: Google says it checks your Android project source files whenever you compile, and in a project where those files were generated from a template, a finding usually points at code you do not own and should not hand-edit.
The profilers sit in between. They measure the Android process, which is the correct unit for native memory, for a heap dump, and for seeing that your app is holding a bitmap it should have released. They are the wrong unit for finding out which component re-rendered, because that happens inside the JavaScript engine the app ships. That work belongs with Hermes and the new architecture, not in the IDE. One more tool is worth knowing by name if you inherited a build rather than made it. Google describes apkanalyzer, which ships in the SDK command-line tools, as providing insight into the composition of your build after the build process completes. The IDE has a window of the same name. It is the one case where the Android tooling tells you something about an app nobody on your side wrote.
Android Developers, Meet Android Studio, on Layout Inspector and the profilers, read 17 October 2026
The same job, in the window and on the command line
| The job | In Android Studio | With the SDK packages alone | Same result either way |
|---|---|---|---|
| Install and update SDK packages | SDK Manager window | sdkmanager | Yes |
| Compile the Android app | Build menu, Gradle underneath | Gradle, or the framework run command | Yes |
| Create a virtual device | Device Manager | avdmanager | Yes |
| Start the emulator | Run, with a device picked | emulator | Yes |
| Read device and app logs | Logcat window | adb, which invokes logcat | Yes |
| See what is inside a finished build | APK Analyzer | apkanalyzer | Yes |
| Inspect why a screen renders slowly | Layout Inspector, documented for Compose | The framework's own dev tools | No |
Package and command names from Google's command-line tools reference, last updated 25 September 2026, read 17 October 2026.
Where this lands if a builder generated your app
Newly is an AI app builder. You describe an app and it writes a real React Native and Expo project that you own, with two-way GitHub sync so the code is yours to read and to move. It uploads iOS builds to TestFlight, publishes to Google Play internal testing and builds a standalone Android APK. It is $25 a month, with no free tier. The part that matters on this page is where the compile happens: off your machine. The first version of your app can be on a real phone before an Android SDK exists on your laptop.
That removes the toolchain from the critical path. It does not remove it from your life. Once the app has users, the questions that arrive are the ones only the native log answers, which means adb, which means a package from the SDK. When a hardware feature needs testing on a device you do not own, that means the emulator. Neither of those is a reason to learn an IDE built for Kotlin authors, and both of them are a reason to have its parts within reach.
Two honest boundaries, since they decide what happens at the end of a project. A generated Android build reaches internal testing by itself, and promoting it to a public release is a decision you make in the Play Console, not something a builder does for you. And on the iOS side, Apple requires the content owner to submit the app, so nobody can press that button on your behalf. Owning the project means owning those two moments, which is a fair trade for not owning a toolchain.
Questions people ask about what Android Studio is for
Android Developers describes Android Studio as the official integrated development environment for Android app development, based on the code editor and developer tools from IntelliJ IDEA. Its own summary of what it adds is a Gradle-based build system, a fast and feature-rich emulator, one environment for developing for all Android devices, Live Edit for updating composables on emulators and devices in real time, code templates and GitHub integration, testing tools and frameworks, lint checks for performance, usability and version compatibility problems, and C++ and NDK support. Read on the Meet Android Studio page on 17 October 2026, which carries a last updated date of 16 October 2026.
Describe the app, then decide what belongs on your machine
Get the app onto a phone first. Install adb when the first real crash arrives, the emulator when you need a screen size you do not own, and the IDE only if a day comes when you are editing Android code yourself.
Start building