Android Developer Setup: Install Android Studio and the SDK

A working Android development environment is three things: Android Studio (Google's official IDE, which bundles a JDK), the Android SDK (platforms, build tools, platform-tools with adb), and somewhere to run the app, either the Android Emulator or a real phone with USB debugging on. Install Android Studio, let its Setup Wizard download the SDK, create an Empty Activity project and press Run. The steps below cover Windows, macOS and Linux as of October 2026, when the current stable release is Android Studio Rabbit 1 (2026.2.1).

What you need before you start

These are the official minimums from the Android Studio install page. The emulator is what pushes them up.

	Windows	macOS	Linux
OS	64-bit Windows 10 or later	macOS 12 or later	64-bit distro with GNOME, KDE or Unity; glibc 2.31+
RAM	8 GB (16 GB with the emulator), 32 GB recommended	8 GB (16 GB with the emulator)	8 GB (16 GB with the emulator)
Disk	8 GB free (16 GB with the emulator), SSD recommended	same	same
CPU	Virtualization (Intel VT-x or AMD-V) enabled in BIOS	Apple M1 or newer, or 6th-gen Intel Core+	Virtualization enabled in BIOS
Not supported	ARM-based Windows PCs	Intel Macs are being phased out	ARM-based Linux machines

Honest advice: 8 GB of RAM runs the IDE, but the IDE plus an emulator plus a browser will swap. If you only have 8 GB, test on a physical phone instead of the emulator.

You do not need to install Java separately. Android Studio ships with its own JDK, and Gradle uses it by default.

Step 1: Install Android Studio

Download it from developer.android.com/studio. Then:

Windows

1. Run the .exe installer (recommended) and accept the defaults.
2. If you chose the .zip, unpack it into Program Files and run android-studio\bin\studio64.exe.

macOS

1. Open the .dmg (pick the Apple chip build on M-series Macs).
2. Drag Android Studio into Applications and launch it.

Linux

1. On 64-bit Ubuntu, first install the 32-bit libraries the tools need:

sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1 libbz2-1.0:i386

2. Unpack the .tar.gz into /opt/ (shared) or /usr/local/, then run:

cd /opt/android-studio/bin
./studio

3. Use Tools > Create Desktop Entry to add it to your app launcher.

ChromeOS works too (install Linux for ChromeOS, then the .deb), but it can only deploy to a connected hardware device, not an emulator.

Step 2: Run the Setup Wizard (this installs the Android SDK)

On first launch, choose whether to import old settings, then follow the Setup Wizard with the Standard install type. It downloads the Android SDK, SDK Platform-Tools, the emulator and a system image. This is the step most "Android SDK tutorial" searches are really about: you rarely need to install the SDK by hand.

Default SDK locations:

• Windows: %LOCALAPPDATA%\Android\Sdk
• macOS: ~/Library/Android/sdk
• Linux: ~/Android/Sdk

To add or update SDK packages later, open Tools > SDK Manager. The SDK Platforms tab picks Android versions (API levels) to compile against; SDK Tools has Build-Tools, Platform-Tools, the Emulator, and optional pieces like the NDK and CMake.

Keep Android Studio itself current with Help > Check for Updates (Windows/Linux) or Android Studio > Check for Updates (macOS). Google notes that Gemini in Android Studio and Firebase Crashlytics integration only work with versions released in roughly the last 10 months.

Step 3: Set environment variables (only if you use the command line)

Android Studio doesn't need these, but adb, Flutter, React Native and CI scripts do. Per the environment variables reference, use ANDROID_HOME; ANDROID_SDK_ROOT is deprecated.

macOS or Linux (~/.zshrc or ~/.bashrc):

export ANDROID_HOME="$HOME/Library/Android/sdk"   # Linux: $HOME/Android/Sdk
export PATH="$PATH:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator"

Windows (PowerShell, then open a new terminal):

setx ANDROID_HOME "$env:LOCALAPPDATA\Android\Sdk"
setx PATH "$env:PATH;$env:LOCALAPPDATA\Android\Sdk\platform-tools"

Check it worked:

adb version

Command-line only setup (CI servers, headless boxes)

If you don't want the IDE, download the Command line tools only package from the same download page and place it so the path is android_sdk/cmdline-tools/latest/bin/. Then install packages with sdkmanager:

sdkmanager --list
sdkmanager "platform-tools" "platforms;android-36" "build-tools;36.0.0"
sdkmanager --licenses

Run sdkmanager --list first and use the newest platform it shows. Google now marks sdkmanager as deprecated in favor of the new Android CLI (android sdk install|list|update|remove); existing sdkmanager scripts still work for now.

Step 4: Set up the Android Emulator

1. Open Device Manager (right sidebar, or View > Tool Windows > Device Manager).
2. Click + > Create Virtual Device, pick a phone (e.g. a Pixel), then a recent system image, and finish.
3. Start it with the play button.

The emulator needs hardware acceleration, and that is where most setups break. Check your machine with:

emulator -accel-check

Per the emulator acceleration guide:

• Windows: use Windows Hypervisor Platform (WHPX). Enable it in Turn Windows features on or off > Windows Hypervisor Platform, then restart. The older Android Emulator Hypervisor Driver (AEHD) is being retired on December 31, 2026, and Intel HAXM is no longer used at all (removed in emulator 36.2).
• macOS: nothing to install; the emulator uses Apple's Hypervisor.Framework.
• Linux: install KVM (sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils on Ubuntu) and confirm with sudo kvm-ok.

Don't run the emulator inside another VM, WSL or Docker; it has to run on the host.

Step 5: Or use a real phone

A physical device is faster and closer to what users have.

1. On the phone, open Settings > About phone and tap Build number seven times until you see "You are now a developer!" (on Samsung it's Settings > About phone > Software information > Build number). See Configure developer options.
2. Go to Settings > System > Developer options and turn on USB debugging.
3. Plug in the phone and accept the "Allow USB debugging?" prompt.
4. On Windows, install your phone maker's USB driver if it isn't detected. On Ubuntu, add yourself to the plugdev group (sudo usermod -aG plugdev $LOGNAME, then log out and in) and install android-sdk-platform-tools-common. macOS needs nothing.
5. Run adb devices; your phone should be listed.

On Android 11 and later you can skip the cable: enable Wireless debugging in Developer options, then in Android Studio choose Pair Devices Using Wi-Fi from the device menu and scan the QR code (details).

Step 6: Build and run your first app

1. On the Welcome screen click New Project (or File > New > New Project).
2. Under Phone and Tablet, choose Empty Activity. This is the Jetpack Compose template.
3. Set a name, keep the default package name, and choose a Minimum SDK (API 24, Android 7.0, is the choice Google's first-app codelab uses).
4. Click Finish and wait for the first Gradle sync. It downloads dependencies and can take several minutes the first time.
5. Pick your emulator or phone in the device dropdown and click Run (the green triangle).

The template's MainActivity.kt looks like this, and the @Preview function renders in the Design pane without running anything:

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyAppTheme {
                Greeting("Android")
            }
        }
    }
}

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(text = "Hello $name!", modifier = modifier)
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    MyAppTheme { Greeting("Android") }
}

(MyAppTheme is generated from your project name.)

Common setup problems

• "HAXM is not installed" or the emulator won't start on Windows: HAXM is gone. Turn on Windows Hypervisor Platform and make sure virtualization is enabled in BIOS/UEFI.
• Gradle sync fails behind a proxy: set the proxy in Settings > Appearance & Behavior > System Settings > HTTP Proxy, then retry the sync.
• Phone not listed in adb devices: try another cable (many are charge-only), re-accept the debugging prompt, or use Tools > Troubleshoot Device Connections.
• Out of disk space: each system image is several GB. Delete unused virtual devices in Device Manager and old platforms in SDK Manager.

Do you have to use Android Studio?

For native Android (Kotlin, Jetpack Compose), yes in practice: the layout preview, profilers, emulator management and Gradle integration all live there. You can write code in another editor and build with ./gradlew assembleDebug, but you'll still need the SDK. Cross-platform frameworks such as Flutter and React Native let you code in VS Code, yet they still require the Android SDK and usually an emulator installed through Android Studio. We compare the options in the best Android IDEs, and you can browse mobile development tools and IDEs launched on DevHunt.

FAQ

What is the Android development environment?

It's Android Studio (IDE with a bundled JDK and Gradle), the Android SDK (platform libraries, build tools, adb), and a run target: the Android Emulator or a physical device. Android Studio's Setup Wizard installs all of it.

Can I set up Android development on Windows?

Yes. You need 64-bit Windows 10 or later on an Intel or AMD CPU with virtualization enabled; ARM-based Windows PCs aren't supported. Turn on Windows Hypervisor Platform for the emulator.

Do I need to install the Android SDK separately?

No. The Setup Wizard downloads it. Install it separately (the command-line tools plus sdkmanager) only for CI servers or headless machines. More in our guide to downloading the Android SDK.

How much RAM does Android Studio need?

8 GB minimum for the IDE alone, 16 GB if you also run the emulator, and Google recommends 32 GB. With 8 GB, use a real phone instead of the emulator.

Is Android Studio free?

Yes. Android Studio and the SDK are free for any use, including commercial apps. Publishing to Google Play requires a one-time developer account registration fee, which is separate.