How to Install Flutter

Flutter 3.47.9 is the latest stable release as of October 2026, bundled with Dart 3.13.7, and installing it correctly from day one, alongside Shorebird for over-the-air updates, eliminates the most common developer pain points, such as broken PATH variables, missing Android SDK command-line tools, and iOS dependency problems.

This guide covers exact commands and configuration for macOS, Windows, and Linux, prioritizing the professional workflow used in production teams. macOS is the only host that can build both iOS and Android apps, which makes it the usual choice for mobile teams. Desktop apps build on their own OS: the Flutter tool builds Windows apps only on Windows and Linux apps only on Linux ("build windows" only supported on Windows hosts.).

System requirements and prerequisites across all platforms

A realistic production setup, including the Flutter SDK, Android SDK, emulator images, and an IDE, needs 10 GB or more of free space. The official docs do not specify a hard RAM floor, but community consensus and practical experience put the minimum at 8 GB, with 16 GB strongly recommended when running Android emulators or iOS simulators alongside an IDE.

Every platform requires Git 2.x as a prerequisite. On macOS, Git ships with Xcode Command-Line Tools. On Windows, install Git for Windows. On Ubuntu, sudo apt-get install git handles it. Verify with git --version before proceeding.

Here’s a quick rundown of the requirements for each platform:

Requirement	macOS	Windows	Linux (Ubuntu LTS)
Disk space	10 GB+ recommended	10 GB+ recommended	10 GB+ recommended
RAM	8 GB min, 16 GB ideal	8 GB min, 16 GB ideal	8 GB recommended
Git	Via Xcode CLI tools	Git for Windows	`apt-get install git`
Additional	Xcode (for iOS and macOS apps)	Visual Studio with C++ (for Windows apps)	`curl`, `unzip`, `xz-utils`, `zip`, `libglu1-mesa`

The devices and OS versions your app can run on are a separate list, in Flutter’s supported deployment platforms.

Flutter bundles the Dart SDK, no separate Dart installation is needed.

Always use the stable channel for production work. Four stable releases are planned for 2026.

macOS installation

macOS setup carries the most complexity because it’s the only platform supporting both iOS and Android development simultaneously. The single biggest architectural decision is whether you’re on Apple Silicon (M1/M2/M3/M4) or Intel, because Homebrew install paths, Ruby environments, and emulator image choices all differ.

Installing the Flutter SDK

Flutter’s own docs recommend installing with VS Code, which downloads the SDK and adds it to your PATH, or a manual install. Homebrew also has a community-maintained cask, which selects the correct architecture for you:

brew install --cask flutter

For a manual install, download the architecture-specific zip from the Flutter SDK archive. Apple Silicon uses the flutter_macos_arm64_*.zip bundle and Intel uses flutter_macos_*.zip. Flutter is phasing out support for Intel Macs.

Once downloaded, extract the zip to a development directory:

mkdir -p ~/develop
unzip ~/Downloads/flutter_macos_arm64_3.47.9-stable.zip -d ~/develop/

For manual installs, add Flutter to your PATH. Since macOS defaults to zsh (since Catalina), edit ~/.zshrc:

export PATH="$HOME/develop/flutter/bin:$PATH"

For bash users, add the same line to ~/.bash_profile. Apple Silicon users also need Homebrew’s shell environment configured:

eval "$(/opt/homebrew/bin/brew shellenv)"

Intel users must substitute /usr/local/bin/brew. You can verify your Flutter CLI installation with the which flutter and flutter --version commands.

Xcode and iOS toolchain

Install the latest Xcode from the Mac App Store, then run these commands in sequence (Flutter’s iOS setup):

xcode-select --install
sudo sh -c 'xcode-select -s /Applications/Xcode.app/Contents/Developer && xcodebuild -runFirstLaunch'
sudo xcodebuild -license accept
xcodebuild -downloadPlatform iOS

iOS plugin dependencies

Since Flutter 3.44, Flutter manages iOS and macOS plugin dependencies with Swift Package Manager by default, so a new project needs no extra install. Flutter falls back to CocoaPods for any plugin that doesn’t support Swift Package Manager yet, so install CocoaPods only if your app uses such a plugin or flutter doctor asks for it. CocoaPods is in maintenance mode, and its registry becomes read-only on December 2, 2026.

If you do need CocoaPods, install it with Homebrew:

brew install cocoapods

The system Ruby shipped with macOS is too old for current CocoaPods releases. If the Homebrew install doesn’t work, install a newer Ruby first and then install CocoaPods with gem:

brew install ruby
echo 'export PATH="/opt/homebrew/opt/ruby/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
gem install cocoapods

Never use sudo gem install with the system Ruby.

Windows and Linux installation procedures

Windows 10/11 setup

After installing Git for Windows, the Flutter team recommends the VS Code quick-install path:

Install VS Code
Add the Flutter extension
Open the Command Palette (Ctrl+Shift+P)
Type Flutter: New Project, and VS Code will prompt you to download the SDK and add it to PATH automatically.

For manual installation, download the latest .zip from the Flutter SDK archive and extract it to a path without spaces or special characters (as a reminder, never use C:\Program Files\). A good choice is %USERPROFILE%\develop\:

Expand-Archive -Path $env:USERPROFILE\Downloads\flutter_windows_3.47.9-stable.zip -Destination $env:USERPROFILE\develop\

Next, to add Flutter to your path, configure PATH through System Properties → Advanced → Environment Variables. Edit the Path user variable and add C:\Users\{username}\develop\flutter\bin. Move this entry to the top of the list. Once done, close and reopen all terminal windows to ensure the new path gets applied.

Three Windows-specific gotchas trip up nearly every developer.

First, Microsoft Defender scanning Flutter’s many small files slows builds down, and antivirus software can quarantine flutter.bat while you extract the SDK. Add exclusions for the Flutter SDK directory and the pub cache (%LOCALAPPDATA%\Pub\Cache) from an administrator PowerShell:

Add-MpPreference -ExclusionPath "C:\Users\{username}\develop\flutter"
Add-MpPreference -ExclusionPath "$env:LOCALAPPDATA\Pub\Cache"

Second, Developer Mode must be enabled for building Windows apps with plugins (Settings → Privacy & Security → For Developers → Developer Mode: On).

Third, for Windows desktop development, you need Visual Studio 2022+ with the “Desktop development with C++” workload. Remember, this is Visual Studio, not VS Code.

Linux (Ubuntu LTS) setup

To get started, install required dependencies first:

sudo apt-get update -y && sudo apt-get upgrade -y
sudo apt-get install -y curl git unzip xz-utils zip libglu1-mesa

The simplest method to install Flutter is via snap:

sudo snap install flutter --classic

To install Flutter manually, download the .tar.xz from the SDK archive and extract:

mkdir -p ~/develop
tar -xf ~/Downloads/flutter_linux_3.47.9-stable.tar.xz -C ~/develop/

echo 'export PATH="$HOME/develop/flutter/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

For Linux desktop development, additional packages are required as documented in the Flutter Linux desktop setup guide:

sudo apt-get install -y clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-12-dev

Never run Flutter commands with sudo on Linux, as this can create permission issues that are painful to unwind.

Android SDK setup

Regardless of your operating system, the Android toolchain is where most flutter doctor failures occur.

To get started, install the latest Android Studio from the Android Studio download page. During the setup wizard, Android Studio installs the base SDK. But the wizard does not install everything Flutter needs.

To do that, open the SDK Manager (Android Studio → Tools →SDK Manager, or from the welcome screen: More Actions → SDK Manager). You need to configure two tabs:

In the SDK Platforms tab, install the platform for API Level 36 (Android 16).
In the SDK Tools tab (this is the critical step that most guides gloss over) ensure all four of these are checked:
- Android SDK Command-line Tools (latest), the #1 most common missing component
- Android SDK Build-Tools (latest)
- Android SDK Platform-Tools (includes adb)
- Android Emulator

Click Apply and confirm.

Without the command-line tools specifically, flutter doctor will fail with: cmdline-tools component is missing.

Environment variables for the Android SDK

Set ANDROID_HOME and add platform-tools to PATH. The default SDK locations differ by OS:

macOS (~/.zshrc):

export ANDROID_HOME="$HOME/Library/Android/sdk"
export PATH="$PATH:$ANDROID_HOME/platform-tools"
export PATH="$PATH:$ANDROID_HOME/cmdline-tools/latest/bin"
export PATH="$PATH:$ANDROID_HOME/emulator"

Windows (System Environment Variables):

Variable: ANDROID_HOME = C:\Users\{username}\AppData\Local\Android\Sdk
Add to PATH: %ANDROID_HOME%\platform-tools and %ANDROID_HOME%\cmdline-tools\latest\bin

Linux (~/.bashrc):

export ANDROID_HOME="$HOME/Android/Sdk"
export PATH="$PATH:$ANDROID_HOME/platform-tools"
export PATH="$PATH:$ANDROID_HOME/cmdline-tools/latest/bin"

After configuring the SDK, accept all Android licenses:

flutter doctor --android-licenses

Type y at each prompt. This step is mandatory before Flutter can build any Android app.

Shorebird CLI belongs in your initial setup, not as an afterthought

Shorebird, founded by Flutter creator Eric Seidel, enables over-the-air Code Push, pushing Dart code updates directly to users’ devices without waiting for App Store or Play Store review.

Installing it alongside Flutter from day one avoids the common “retrofit under pressure” scenario where teams scramble to add OTA capability while rushing to fix a production bug. A patch can only update an app version that was built with shorebird release, so a build you shipped with plain flutter build can’t receive patches.

Installation commands

macOS / Linux:

curl -fsSL https://shorebird.dev/install.sh | bash

Windows (PowerShell):

Set-ExecutionPolicy RemoteSigned -scope CurrentUser
irm https://shorebird.dev/install.ps1 | iex

Shorebird installs to ~/.shorebird/bin and automatically adds itself to PATH. It also installs a private copy of Flutter inside ~/.shorebird/bin/cache/flutter, this is Shorebird’s modified Flutter for Code Push and should not be added to your PATH.

You can verify the installation by running this:

shorebird --version
shorebird doctor

The shorebird doctor output checks connectivity to Shorebird’s API, auth, console, download, storage, and CDN endpoints, and checks that Shorebird is up-to-date. A clean output looks like this (the checks after the endpoints depend on your project):

✓ https://api.shorebird.dev OK
✓ https://auth.shorebird.dev OK
✓ https://console.shorebird.dev OK
✓ https://download.shorebird.dev OK
✓ https://storage.googleapis.com OK
✓ https://cdn.shorebird.cloud OK

✓ Shorebird is up-to-date
✓ Xcode project does not override FLUTTER_ build settings

No issues detected!

The core workflow to get started is:

shorebird login (authenticates your Shorebird account)
Initialize your project with shorebird init (creates shorebird.yaml with your app ID)
Create a release with shorebird release android or shorebird release ios,
Push OTA updates with shorebird patch android/ios.

For a new project, shorebird create runs flutter create and then shorebird init in one step.

Shorebird is purely CLI-driven and works seamlessly alongside the standard Flutter and Dart VS Code extensions.

VS Code configuration for professional Flutter development

Install the Flutter extension (ID: Dart-Code.flutter) from the VS Code marketplace. It automatically installs the Dart extension (Dart-Code.dart-code) as a dependency. These two extensions provide debugging, hot reload, widget inspector, code completion, refactoring, and snippets.

After installation, open the Command Palette (Ctrl + Shift + P) and run Dart: Use Recommended Settings to apply sensible defaults, or add these to your settings.json:

{
  "[dart]": {
    "editor.formatOnSave": true,
    "editor.formatOnType": true,
    "editor.rulers": [80],
    "editor.selectionHighlight": false,
    "editor.wordBasedSuggestions": "off",
    "editor.tabCompletion": "onlySnippets"
  },
  "editor.codeActionsOnSave": {
    "source.fixAll": true
  },
  "debug.internalConsoleOptions": "openOnSessionStart"
}

Key shortcuts to remember:

F5 starts debugging
Ctrl+F5 / Cmd+F5 triggers hot reload during a debug session (saving a file also hot reloads)
Ctrl+Shift+F5 performs a hot restart
Ctrl+. / Cmd+. opens quick-fix actions for wrapping or extracting widgets.

Creating a new project is done through the Command Palette: Flutter: New Project → select Application → choose directory → enter name.

Reading `flutter doctor` output and fixing what’s broken

Run flutter doctor -v (verbose mode) after completing setup. The command checks the Flutter SDK, each platform toolchain you can build for (Android, Xcode on macOS, Chrome, desktop), connected devices, and network resources. Each line is prefixed with one of three symbols:

Symbol	Meaning	Action needed
[✓]	Passed	None
[!]	Warning	May need attention; development often still works
[✗]	Error	Must fix before building for that platform

A fully healthy macOS output looks like this example (your versions, paths and devices will differ):

[✓] Flutter (Channel stable, 3.41.4, on macOS 26.2 25C56 darwin-arm64, locale
    en-IN) [605ms]
    • Flutter version 3.41.4 on channel stable at
      /Users/<username>/development/flutter
    • Upstream repository https://github.com/flutter/flutter.git
    • Framework revision 582a0e7c55 (5 days ago), 2026-02-12 17:12:32 -0800
    • Engine revision 3452d735bd
    • Dart version 3.11.1
    • DevTools version 2.54.1
    • Feature flags: enable-web, enable-linux-desktop, enable-macos-desktop,
      enable-windows-desktop, enable-android, enable-ios, cli-animations,
      enable-native-assets, omit-legacy-version-file, enable-lldb-debugging,
      enable-uiscene-migration

[✓] Android toolchain - develop for Android devices (Android SDK version 36.1.0)
    [1,702ms]
    • Android SDK at /Users/<username>/Library/Android/sdk
    • Emulator version 33.1.24.0 (build_id 11237101) (CL:N/A)
    • Platform android-36-ext19, build-tools 36.1.0
    • Java binary at: /Applications/Android
      Studio.app/Contents/jbr/Contents/Home/bin/java
      This is the JDK bundled with the latest Android Studio installation on
      this machine.
      To manually set the JDK path, use: `flutter config
      --jdk-dir="path/to/jdk"`.
    • Java version OpenJDK Runtime Environment (build
      17.0.10+0-17.0.10b1087.21-11572160)
    • All Android licenses accepted.

[✓] Xcode - develop for iOS and macOS (Xcode 26.2) [1,475ms]
    • Xcode at /Applications/Xcode.app/Contents/Developer
    • Build 17C52
    • CocoaPods version 1.16.2

[✓] Chrome - develop for the web [7ms]
    • Chrome at /Applications/Google Chrome.app/Contents/MacOS/Google Chrome

[✓] Connected device (3 available) [7.2s]
    • User’s iPhone (wireless) (mobile) • 00XXXX01-00XXXXXXXXXXXX1E • ios
      • iOS 26.0 2XXXX1
    • macOS (desktop)                    • macos                     •
      darwin-arm64   • macOS 26.2 25C56 darwin-arm64
    • Chrome (web)                       • chrome                    •
      web-javascript • Google Chrome 144.0.7559.135

[✓] Network resources [6.8s]
    • All expected network resources are available.

• No issues found!

The most frequently encountered errors and their fixes:

flutter: command not found, Flutter is not in PATH. Re-add the export PATH=... line to the correct shell config file (~/.zshrc, ~/.bashrc, or Windows Environment Variables) and restart your terminal.
cmdline-tools component is missing, Open Android Studio → Tools → SDK Manager → SDK Tools tab → check “Android SDK Command-line Tools (latest)” → Apply.
Android license status unknown, Run flutter doctor --android-licenses and accept each license with y.
Unable to find bundled Java version, Newer Android Studio versions renamed the jre directory to jbr. On macOS, create a symlink: cd "/Applications/Android Studio.app/Contents" && ln -s jbr jre. This issue is resolved in recent Flutter+Android Studio combinations, but persists if either is outdated.
CocoaPods failures on Apple Silicon (only for plugins that still use CocoaPods), Ensure you’re using Homebrew Ruby, not system Ruby. Run which ruby, it should show /opt/homebrew/opt/ruby/bin/ruby, not /usr/bin/ruby. Reinstall CocoaPods via brew install cocoapods if needed.
Lock file errors during pub get, Run flutter clean, then flutter pub cache repair, then flutter pub get. If persistent, delete pubspec.lock and retry.
“No devices available”, Either no emulator is running, no physical device is connected, or platform support isn’t enabled. Start an emulator from Android Studio’s Device Manager or run flutter emulators --launch with an available emulator name.

Conclusion

The Flutter installation process has matured significantly: the VS Code quick-install path handles SDK download and PATH configuration in one step, and Swift Package Manager has replaced the historically fragile CocoaPods dependency chain for most iOS projects.

Three setup decisions matter most for production teams: choosing Homebrew on macOS or the VS Code install path (both handle architecture differences automatically), installing Android SDK Command-line Tools explicitly via SDK Manager (the universal failure point that no wizard handles automatically), and integrating Shorebird from project inception rather than retrofitting it under deadline pressure.

To confirm everything works, run flutter doctor -v and shorebird doctor after every installation step. If both report no issues, your environment is production-ready.

Next steps

Now that your Flutter environment is properly configured, here are strategic next steps based on your project needs:

For production deployment planning: Explore Shorebird’s Code Push system architecture to understand how over-the-air updates work at a technical level, then review update strategies to determine when patches download and apply in your app’s lifecycle.

For team collaboration: Set up organizations in Shorebird to manage team access and permissions, and integrate with your CI/CD pipeline using GitHub Actions, Codemagic, or generic CI systems.

For security-conscious environments: Review patch signing to cryptographically verify patch authenticity, understand Shorebird’s security model, and learn about obfuscation and security tooling integration.

For staged rollouts: Implement percentage-based rollouts to gradually deploy patches to user segments, set up staging patches for internal testing, and understand patch rollback procedures for emergency scenarios.

For multi-flavor apps: Configure flavors to manage separate development, staging, and production builds with independent patch tracks.