How to Install Flutter Without Android Studio in 2026

You can apply this how to install Flutter without Android Studio in 2026 guide using just three core components: Flutter SDK, Java Development Kit (JDK 17 or 21), and Android SDK Command-line Tools. All code is written in a lightweight editor like Visual Studio Code (VS Code), saving your computer's RAM and storage space.

A pure Command-line Tools method only needs about 1.5 to 3 GB of space depending on the platform version you install. Compare this to a full Android Studio installation and its default bundles, which consume 5 to 10 GB of storage and eat up 2 to 4 GB of RAM while idle.

This article updates the older guide by Ihwan on Easyread that previously helped many laptop owners with limited SSD capacity. The main idea remains relevant, but almost all technical details have changed. Blindly copying commands from outdated guides will break your system configuration today.

What Changed Since the Old Guide

The 2020 guide was written for the Flutter 1.x era, JDK 8, and Android API 29. Today, the Google Play Console requires a minimum target API ranging from Android 14 (API 34) to Android 15 and 16 (API 35/36), while the modern Gradle ecosystem demands much newer Java versions.

Three architectural changes often trap developers during manual installations:

1. JDK 17 or 21 LTS Requirement: Android Gradle Plugin (AGP) version 8.x and above refuses to run on JDK 8 or JDK 11. On the other hand, using a non-LTS JDK that is too new (like JDK 23) often triggers compatibility issues in Gradle scripts.
2. latest Subfolder Structure: The tools directory was removed a long time ago. The sdkmanager tool must now be placed inside a nested structure <ANDROID_HOME>/cmdline-tools/latest/bin/. Without the latest folder, the terminal will constantly reject your commands.
3. ANDROID_SDK_ROOT Deprecation: Google officially retired the ANDROID_SDK_ROOT variable and set ANDROID_HOME as the single pointer for the Android SDK directory.

This terminal based approach is not just a hack for low spec laptops. When you set up a headless CI/CD build server like GitHub Actions or connect a mobile app to a modern edge serverless backend architecture, you will use the exact same command-line method.

Prerequisites Before Installation

Before opening the terminal, download these five basic software tools. All are free and sourced directly from official repositories:

• Git: Download from the official Git website if it is not already installed on your computer. Flutter depends on Git to download updates and manage SDK versions.
• OpenJDK 17 or 21 LTS: Download via Eclipse Temurin (Adoptium) or Microsoft Build of OpenJDK. Choose the .msi (Windows) or .pkg (macOS) installer and check the option to set the JAVA_HOME variable automatically during installation. Linux or macOS users can also install it via the apt package manager or Homebrew.
• Flutter SDK: Download the latest zip archive from the Flutter manual installation page.
• Android Command-line Tools: Open the Android Studio download page, scroll to the very bottom to the "Command line tools only" table, and download the zip package for your operating system.
• Visual Studio Code: A lightweight text editor where we write Dart code and run the debugger.

How to Install Flutter Without Android Studio in 2026

The step by step guide below uses the C:\Android directory on Windows as an example. Linux and macOS users can adjust the location to ~/Android. Avoid placing the SDK inside a folder that contains spaces or requires administrator privileges like C:\Program Files.

Structure the SDK Folder Correctly

Create a parent folder C:\Android. Extract the Flutter SDK archive into it to form the path C:\Android\flutter (you can also place it in C:\src\flutter or ~/development/flutter as long as you are consistent when registering the PATH variable).

Next, create the folder C:\Android\sdk\cmdline-tools. Extract the contents of the command-line tools archive you downloaded earlier. Inside that archive, there is a folder named cmdline-tools that directly contains the bin and lib folders, and a source.properties file.

Rename the extracted folder to latest, then place it inside C:\Android\sdk\cmdline-tools\. The final result must form the directory structure below:

• C:\Android\flutter\bin\
• C:\Android\sdk\cmdline-tools\latest\bin\
• C:\Android\sdk\cmdline-tools\latest\lib\

If the bin folder sits directly under cmdline-tools without the latest folder in between, sdkmanager will stop working and show a cmdline-tools component is missing error message.

Register ANDROID_HOME and PATH Variables

We need to tell the operating system where Flutter, Java, and the Android SDK are located. Open a regular PowerShell (not as Administrator), then run this command block to save variables at the User level:

powershell

Copy

[Environment]::SetEnvironmentVariable("ANDROID_HOME", "C:\Android\sdk", "User")

$p = [Environment]::GetEnvironmentVariable("Path", "User")
[Environment]::SetEnvironmentVariable("Path", "$p;C:\Android\flutter\bin;C:\Android\sdk\cmdline-tools\latest\bin;C:\Android\sdk\platform-tools", "User")

If you did not set JAVA_HOME when installing OpenJDK, register its location using the command setx JAVA_HOME "C:\Program Files\Eclipse Adoptium\jdk-17..." matching the JDK installation folder on your computer.

For macOS or Linux users, open the ~/.zshrc or ~/.bashrc file using a text editor, then add these configuration lines at the very bottom:

bash

Copy

export ANDROID_HOME="$HOME/Android/sdk"
export JAVA_HOME="/path/to/jdk-17"
export PATH="$PATH:$HOME/Android/flutter/bin:$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools"

Close your PowerShell or terminal window, then open a new window to reload the newly set environment variables. Test your success by running flutter --version and java -version.

Install Essential Packages via sdkmanager

Now we will download the Android compilation components directly from the terminal. You only need three main packages: platform-tools (contains ADB for phone communication), platforms (Android API framework), and build-tools (APK builder tools).

Run the following commands in the terminal:

bash

Copy

sdkmanager --update
sdkmanager --install "platform-tools" "platforms;android-35" "build-tools;35.0.0"

If your project targets Android 16, change the number 35 to 36 ("platforms;android-36" and "build-tools;36.0.0"). You do not need to download additional components like NDK and CMake right now because Gradle will download them automatically if a plugin requires them during compilation.

Link the SDK to Flutter and Accept Licenses

Tell the Flutter internal configuration the exact location of the Android SDK folder, then accept all license clauses from Google:

bash

Copy

flutter config --android-sdk "C:\Android\sdk"
flutter doctor --android-licenses

The terminal will display several pages of license agreements. Type y and press Enter repeatedly until all licenses are accepted. Once done, check the installation health with the command:

bash

Copy

flutter doctor -v

Our main goal is to see a green checkmark [✓] in the Flutter, Android toolchain, and VS Code sections. You will still see an exclamation mark [!] Android Studio (not installed). Just ignore that warning because the mark is purely informative and does not block the application compilation process at all.

Configure VS Code to Start Writing Code

Open Visual Studio Code, go to the Extensions menu (Ctrl+Shift+X), then search for and install the official Flutter extension. The Dart language extension will automatically install as well.

Press Ctrl+Shift+P (or F1), type Flutter: New Project, select the Application template, and choose your project save folder. Once the project opens, you are ready to design the app interface by following modern graphic and UI design styles so your product looks neat and functional.

Fast Alternative: PowerShell and Bash Automation Scripts

If you prefer not to create folders and extract zip archives one by one through the file interface, use a one-off provisioning script. This script is also very useful when setting up a CI/CD runner without a graphical interface.

Copy and paste the latest download URL from the official Android Developer page into the $downloadUrl variable, then run this PowerShell script on Windows:

powershell

Copy

$sdkDir = "C:\Android\sdk"
$cmdlineZip = "$env:TEMP\cmdline-tools.zip"
$downloadUrl = "https://dl.google.com/android/repository/commandlinetools-win-latest.zip"

New-Item -ItemType Directory -Force -Path "$sdkDir\cmdline-tools" | Out-Null
Invoke-WebRequest -Uri $downloadUrl -OutFile $cmdlineZip
Expand-Archive -Path $cmdlineZip -DestinationPath "$sdkDir\cmdline-tools" -Force
Rename-Item -Path "$sdkDir\cmdline-tools\cmdline-tools" -NewName "latest"
Remove-Item $cmdlineZip

Linux and macOS users can run the equivalent commands using Bash:

bash

Copy

SDK_DIR="$HOME/Android/sdk"
DOWNLOAD_URL="https://dl.google.com/android/repository/commandlinetools-linux-latest.zip"

mkdir -p "$SDK_DIR/cmdline-tools"
curl -o /tmp/cmdline-tools.zip "$DOWNLOAD_URL"
unzip -q /tmp/cmdline-tools.zip -d "$SDK_DIR/cmdline-tools"
mv "$SDK_DIR/cmdline-tools/cmdline-tools" "$SDK_DIR/cmdline-tools/latest"
rm /tmp/cmdline-tools.zip

Once the script finishes executing, you just need to proceed to the ANDROID_HOME registration stage and execute sdkmanager.

Testing the App Directly on a Physical Phone

Using a physical Android phone as the main test device is the most effective key to saving RAM. Your laptop only handles compiling the code, while the app's graphical processing load is fully handled by the phone's processor.

Enable Developer Options on the Phone

Open the Settings > About phone menu, then tap the Build Number section seven times in a row until a notification appears saying you are now a developer. On Xiaomi, Redmi, or POCO devices, tap on the MIUI Version or Xiaomi HyperOS Version row.

Turn on USB Debugging

Go back to the main Settings menu, navigate to System > Developer options (or Additional settings > Developer options). Slide the USB Debugging toggle to the active position.

Xiaomi/HyperOS users specifically must enable two additional toggles located right below it: Install via USB and USB Debugging (Security settings). Without these two options, VS Code will fail to install the APK to the phone when you run the app.

Connect via Data Cable or Wi-Fi

Plug the phone into the laptop using a data cable that supports file transfers (not a standard charging cable). When the phone screen shows a confirmation window "Allow USB debugging?", check the Always allow from this computer box, then tap Allow.

Check the connection from the VS Code terminal:

bash

Copy

adb devices
flutter devices

Make sure your phone's serial number appears with a device status. If it says unauthorized, unplug the cable and repeat the permission dialog approval on the phone screen. Once detected, press F5 in VS Code or type flutter run to launch the app.

Wireless Debugging over Wi-Fi (Android 11+)

If your laptop USB ports are loose or you do not like dealing with cables on your desk, use the built-in Wireless Debugging feature in Android 11 and above. Ensure your laptop and phone connect to the same Wi-Fi network.

1. Go to Developer options > Wireless debugging, then turn the feature on.
2. Tap the Pair device with pairing code menu. The phone screen will display an IP address, a pairing port, and a six digit code.
3. Run the pairing command in the terminal matching the IP and port shown on the phone screen, then enter the six digit code when prompted:

bash

Copy

adb pair 192.168.1.15:39123

4. Once the status says Successfully paired, look at the main Wireless debugging page on your phone. Note the new IP address and port listed under your device name (this port is different from the pairing port earlier), then connect:

bash

Copy

adb connect 192.168.1.15:41555

Now your phone is ready to receive hot reloads from VS Code without a USB cable.

Gradle Optimization for 8 GB RAM Laptops

One of the biggest complaints when practicing how to install Flutter without Android Studio in 2026 on an 8 GB RAM laptop is the first compilation process draining memory until the computer freezes. The cause is not VS Code, but the background Gradle Daemon process that takes memory allocation too aggressively by default.

You can limit Gradle's RAM usage by creating or editing the global configuration file at C:\Users\<UserName>\.gradle\gradle.properties (Windows) or ~/.gradle/gradle.properties (macOS/Linux). Insert these three settings lines:

ini

Copy

org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m
org.gradle.parallel=true
org.gradle.daemon=true

The -Xmx2048m configuration limits the Java virtual machine for Gradle to use no more than 2 GB of RAM. Combined with VS Code which only uses around 300 to 600 MB of RAM, an 8 GB RAM laptop with a processor like an Intel Core i3 or Ryzen 3 remains free to open a web browser while compiling the project.

Creating an Emulator Without Android Studio (Optional)

What if you still need an Android emulator but refuse to install Android Studio? You can still download the system image and build a pure Android Virtual Device (AVD) through the terminal.

However, remember our initial goal of saving storage space and memory. Downloading a system image and turning on the emulator will consume a significant amount of extra storage and RAM. If your computer specifications are adequate, run these commands:

bash

Copy

sdkmanager "emulator" "system-images;android-35;google_apis;x86_64"
avdmanager create avd -n test_emu -k "system-images;android-35;google_apis;x86_64"

For Mac users with Apple Silicon processors, change the x86_64 architecture in the command above to arm64-v8a. Once the AVD is successfully created, you can turn it on anytime via the emulator -avd test_emu command (or flutter emulators --launch test_emu) or select it directly from the bottom right corner of the VS Code window.

Compromises and Limitations You Need to Know

Cutting out Android Studio provides an agile work environment, but there are three technical compromises you must understand from the start:

• Fully Text Based SDK Management: You do not have a graphical SDK Manager window to check Android versions. To see the list of installed packages, you have to type sdkmanager --list_installed, and to remove them you use sdkmanager --uninstall "<package_name>".
• Absence of Native Profiling Tools: For daily widget tree inspection and app performance monitoring needs, the Flutter DevTools integrated into VS Code is very adequate. However, you lose access to the Android native level memory profiler and the built-in App Inspection of Android Studio.
• Minimal Kotlin/Java Code Editing: If your project frequently modifies the android/ folder to write MethodChannels or overhaul complex Gradle configuration scripts, the Kotlin auto-complete features in VS Code are not as complete as Android Studio's.

For developers focusing on building cross platform interfaces or designers who are studying the UI UX designer and digital product career guide and want to validate their designs directly into Flutter code, these three limitations almost never become obstacles.

Fixing the Most Common Errors

If your installation process or flutter doctor check hits a dead end, match the error message in your terminal with this solution table: