The good news: the setup is entirely manageable when you follow the right sequence. Skip a step (like accepting SDK licenses or configuring PATH), and you'll face errors that are genuinely confusing to trace back.
This guide walks through every step required to go from a blank machine to a verified, working Flutter Android environment — including post-setup validation and fixes for the most common failures.
TL;DR
- Install Flutter SDK first, then Android Studio, then configure environment variables — order matters
- Run
flutter doctorafter setup to identify any missing dependencies - Physical devices need USB debugging enabled; emulators need AVD Manager configuration
- Most failures trace back to a missing PATH entry, unaccepted SDK licenses, or ADB not detecting the device
Flutter Android Development Setup Guide
The setup follows a defined sequence, and deviating from it creates problems that are harder to diagnose later. Budget 45–90 minutes depending on your internet speed and machine specs — SDK downloads alone can take 20–30 minutes on slower connections.
Prerequisites and System Requirements
Before downloading anything, confirm your machine meets the baseline requirements. These are drawn from official Android Studio and Android Emulator documentation.
Operating System:
- Windows 10 or 11 (64-bit)
- macOS 12 or later (Apple M1 or 6th-gen Intel Core minimum; Apple Silicon recommended)
- Linux: 64-bit with glibc 2.31 or later, supporting Gnome, KDE, or Unity
RAM and Disk:
| Use Case | Minimum RAM | Minimum Disk |
|---|---|---|
| Android Studio only | 8 GB | 8 GB free |
| Studio + Emulator | 16 GB | 16 GB free |
| Recommended | 32 GB | 32 GB SSD |
CPU:
- Windows/Linux: Intel with VT-x or AMD with AMD-V enabled in BIOS; post-2017 microarchitecture (Intel 8th Gen i5 or AMD Zen Ryzen minimum)
- ARM-based Windows/Linux CPUs are not currently supported
- macOS: Apple M1 or Intel 6th-gen Core minimum
Additional requirements:
- 64-bit OS is mandatory
- Git must be installed and accessible from the terminal
- Stable internet connection (downloads are large)
- No partial Flutter installs already in PATH that could conflict
Once your machine clears these requirements, you need three pieces of software to get started.
Tools and Software Required
| Tool | Purpose | Notes |
|---|---|---|
| Flutter SDK | Core framework and CLI | Download from flutter.dev |
| Android Studio | Android SDK, AVD Manager, ADB | Bundles the Android SDK — no separate download needed |
| IDE (VS Code or Android Studio) | Code editing and debugging | VS Code is lighter; Android Studio offers deeper Android tooling |
The Android SDK ships inside Android Studio. You do not download it separately — the setup wizard handles it.
For IDE choice: VS Code with the Flutter extension is lighter and faster to launch. Android Studio gives you tighter integration with the Android toolchain and AVD Manager — worth it if you're running emulators frequently. Start with whichever you already have installed.
How to Set Up Flutter for Android Development
The installation sequence matters: Flutter SDK → Android Studio → environment configuration. Reversing this order creates PATH conflicts and SDK detection failures that are frustrating to untangle — so follow the steps below in order.
Step 1 — Download and Extract the Flutter SDK
- Go to the Flutter SDK archive and download the latest stable release for your OS
- Extract the zip to a permanent, user-writable directory
- Windows example:
C:\\Users\\YourName\\develop\\flutter - macOS/Linux example:
~/develop/flutter
- Windows example:
- Avoid paths with spaces or special characters
- Do not place the SDK inside
C:\\Program Files\\on Windows — this requires elevated privileges and causes permission errors
Step 2 — Add Flutter to System PATH
This is the step most commonly skipped, and it causes the flutter: command not found error.
Windows:
- Open System Properties → Environment Variables
- Under "User variables," select
Path→ Edit → New - Add the path to the Flutter
binfolder, for example:%USERPROFILE%\\develop\\flutter\\bin - Close and reopen any terminals and IDEs
macOS:
- Open
~/.zprofilein a text editor - Add:
export PATH="$HOME/develop/flutter/bin:$PATH" - Save and run
source ~/.zprofileor open a new terminal
Linux:
- Run
echo $SHELLto identify your shell - For bash, add
export PATH="<path-to-flutter>/bin:$PATH"to~/.bashrc - For zsh, edit the equivalent zsh startup file
- Run
source ~/.bashrcor open a new terminal
After editing PATH, verify with: flutter --version
Step 3 — Install Android Studio and Android SDK
- Download the latest stable Android Studio from developer.android.com/studio
- Run the installer and follow the setup wizard
- When prompted to select components, ensure these are checked:
- Android SDK
- Android SDK Platform (API Level 36)
- Android Virtual Device
- In SDK Manager → SDK Tools tab, also install the following (Flutter requires all of these to build and run properly):
- Android SDK Build-Tools
- Android SDK Command-line Tools (latest)
- Android SDK Platform-Tools
- Android Emulator
- CMake and NDK (side by side)
- Complete the wizard — it downloads and configures everything automatically
Step 4 — Accept Android SDK Licenses
This step is mandatory — skipping it will block every build attempt.
flutter doctor --android-licenses
Type y and press Enter for each of the 5–7 prompts. If the command fails, see the license error fix below.
Step 5 — Install Flutter and Dart Plugins
With the SDK configured, the final step is adding IDE support so you can create Flutter projects and use hot reload without leaving your editor.
In Android Studio:
- Go to Settings (or Preferences on macOS) → Plugins
- Search for "Flutter" and install it — the Dart plugin installs automatically
In VS Code:
- Open Extensions (Ctrl+Shift+X)
- Search for "Flutter" and install the Flutter extension — Dart installs alongside it
Once installed, both IDEs will recognize Flutter projects, surface device selectors, and support hot reload — you're ready to create your first app.
Setting Up Your Android Device or Emulator
Option A — Android Emulator (AVD)
- Open Android Studio → Device Manager (previously AVD Manager)
- Click Create Device and select a hardware profile (Pixel 6 is a reliable starting point)
- Choose a system image — select the most recent stable API level available
- Click Finish and launch the emulator from Device Manager
Hardware acceleration is critical for usable emulator performance. Current platform-specific options:
- Windows: Enable Windows Hypervisor Platform (WHXP) — Intel HAXM is deprecated as of January 2023
- macOS: Hypervisor.Framework (enabled by default on Apple Silicon)
- Linux: KVM
Enable these through your OS settings or BIOS before running the emulator. Without acceleration, the emulator runs extremely slowly.
Option B — Physical Android Device
- On your device, go to Settings → About Phone
- Tap Build Number seven times until "You are now a developer!" appears
- Go back to Settings → Developer Options and enable USB Debugging
- Connect the device via USB and approve the "Allow USB Debugging?" prompt on screen
- Windows only: If the device doesn't appear, install the OEM USB driver for your device manufacturer
Confirming Detection
Whether you're using an emulator or a physical device, run both commands and confirm your device appears in the output:
adb devices
flutter devices
If either command returns nothing, use these diagnostics:
adb devicesshows nothing — check your USB driver installation or confirm USB Debugging is enabledflutter devicesshows nothing butadb devicesdoes — the issue is in Flutter's SDK configuration, not the device connection
Post-Setup Validation
Run flutter doctor — it scans every component Flutter needs and reports exactly what's working, broken, or missing:
flutter doctor
Interpreting the output:
- ✅ Green checkmark = component is correctly configured
- ⚠ Warning = works but has a non-critical issue (usually a missing optional component)
- ✗ Error = must be fixed before builds will succeed
Check the Android toolchain and Android Studio sections specifically. Every item there should show green before you proceed.
Create and run a test project:
flutter create my_app
cd my_app
flutter run
A successful launch of the default counter app on your emulator or device confirms the full pipeline is working. Once it's running, press r in the terminal to trigger hot reload. If the UI updates instantly without a full restart, Flutter-to-device communication is working end to end.
Common Flutter Android Setup Errors and How to Fix Them
These three errors account for most failed Flutter Android setups. Each fix takes under five minutes once you know the cause.
Android SDK Not Found / Android Toolchain Error in flutter doctor
Problem: flutter doctor reports [✗] Android toolchain — develop for Android devices
Why it happens: The Android SDK path isn't configured, or the Android Studio setup wizard wasn't completed fully — particularly the Command-line Tools component.
Fix:
- Open Android Studio → SDK Manager → SDK Tools tab
- Check Android SDK Command-line Tools (latest) and click Apply
- If the SDK is installed in a non-default location, run:
flutter config --android-sdk <path-to-sdk>
"flutter: command not found" After Installation
Problem: Terminal doesn't recognise the flutter command
Root cause: The Flutter bin directory wasn't added to PATH, or the terminal session wasn't restarted after editing PATH.
Fix:
- Verify the PATH entry points to the correct Flutter SDK
/bindirectory - Open a new terminal window — existing sessions don't pick up PATH changes
- On macOS/Linux, confirm you edited the correct shell config file:
~/.zprofilefor zsh (default on modern macOS),~/.bashrcfor bash
Android Licenses Not Accepted
Problem: Build fails with "Android license status unknown"
Likely cause: flutter doctor --android-licenses was never run, or the JDK version doesn't match what Android Studio expects.
Fix:
- Run
flutter doctor --android-licensesand typeyfor every prompt - If the command fails with a Java error, configure the correct JDK path:
Android Studio bundles its own JDK — use that path if you're unsure which to point to.flutter config --jdk-dir=<path-to-jdk>
Pro Tips for Flutter Android Development
Run flutter doctor before every new project. OS updates, Android Studio upgrades, and SDK changes can silently break an environment that was working fine last week. Catching drift early costs minutes; catching it mid-project costs hours.
Build multiple virtual devices in AVD Manager. Create profiles for a compact phone, a standard phone, a tablet, and a foldable to test layout responsiveness without touching physical hardware. The Device Manager supports all of these form factors and it's faster and cheaper than maintaining a physical device inventory.
Stay on the stable channel. Beta and dev channels introduce breaking changes that can derail active project work:
flutter channel stable
flutter upgrade
Run these periodically to stay current without exposing your project to unstable releases. For teams building production Flutter apps, environment management is just one layer of the work — Codiot's Flutter development team handles the full stack from architecture to deployment, so your team stays focused on the product.
Conclusion
A working Flutter Android environment comes down to three things done correctly:
- PATH configured so the terminal finds Flutter commands
- SDK licenses accepted so builds aren't blocked at the toolchain level
- Device or emulator detected by both ADB and Flutter
Nail those three and your first flutter run will go smoothly.
Don't treat flutter doctor as a one-time setup check. Run it after Android Studio updates, after OS upgrades, and whenever a build starts behaving unexpectedly. Running flutter upgrade regularly keeps your SDK current and compatible with the latest Flutter releases — without falling behind on compatibility.
Frequently Asked Questions
What is Flutter used for?
Flutter is Google's open-source UI toolkit for building natively compiled applications for Android, iOS, web, and desktop from a single codebase using the Dart programming language. It's widely used for both consumer apps and enterprise mobile solutions.
What is a Flutter device?
A Flutter device is any target platform Flutter can deploy to — physical Android or iOS phones, Android emulators, iOS simulators, web browsers, and desktop environments. Run flutter devices to see all connected and available targets.
Do I need Android Studio to develop Flutter apps for Android?
Android Studio isn't required as your IDE — VS Code works well for writing and debugging Flutter code. However, the Android SDK and its tools (installed most easily through Android Studio) are mandatory for any Android Flutter development.
How do I check if my Flutter Android setup is correct?
Run flutter doctor in your terminal. It checks every component of your environment — Flutter SDK, Android toolchain, connected devices, and IDE plugins — and tells you exactly what needs fixing.
Can I run Flutter apps on an Android emulator without a physical device?
Yes. Android Studio's AVD Manager lets you create virtual Android devices for testing. Hardware acceleration (Windows Hypervisor Platform, Hypervisor.Framework on macOS, or KVM on Linux) must be enabled for the emulator to run at acceptable speed.
What is the minimum RAM required for Flutter Android development?
Running Android Studio alone requires at least 8 GB RAM. If you're also running an emulator alongside Studio and the Flutter build system, 16 GB is the practical minimum with 32 GB recommended for smooth parallel workloads.
