How to Install Flutter A Guide for Windows, macOS, and Linux

Getting Flutter up and running involves three key parts: grabbing the Flutter SDK, telling your system where to find it by adding it to the PATH, and then running a quick check with flutter doctor to make sure everything is in place. Once you nail this setup, you're ready to build beautiful, natively compiled apps for mobile, web, and desktop—all from one codebase.

Your First Step into Cross-Platform Development

Nailing the Flutter installation is your ticket into the world of modern app development. What started as a niche Google project has exploded into a major player, letting developers ship to multiple platforms without the headache of managing separate codebases. This guide cuts through the noise to get you set up fast, so you can focus on building, not configuring.

The good news is, the process is much simpler than it used to be. We'll walk through today's best practices, ensuring you have a smooth start whether you're on Windows, macOS, or Linux. If you want to zoom out and see the big picture, you can explore the strategic benefits in our detailed article on cross-platform app development.

The Evolution of Flutter Installation

When Flutter 1.0 launched on December 4, 2018, getting set up was a bit of a manual chore. You had to download the SDK, unzip it to a specific folder like C:srcflutter, and then manually wrestle with your PATH environment variable.

That last step was a huge stumbling block. Stack Overflow data from early 2019 showed 'Flutter PATH not recognized' queries spiking by 300%, tripping up an estimated 25% of newcomers. It was a common and frustrating experience.

Thankfully, the process has matured significantly. Modern tools have automated many of those tricky steps, shifting the focus from just getting it to work to building an efficient development environment right from the start.

This evolution is pretty stark when you compare the early days to the streamlined process we have now.

Flutter Installation at a Glance (2018 vs 2026)

As you can see, what was once an hour-long ordeal is now a much quicker and less error-prone process, letting developers get to coding faster.

The goal has always been to establish a solid foundation. A clean installation prevents countless hard-to-diagnose bugs down the line, especially when you start dealing with the Android and iOS toolchains.

Modern installation methods are built on a few core ideas:

• Automation is Key: Using tools like Homebrew on macOS or Winget on Windows drastically reduces the chance of human error when messing with system variables.
• Constant Verification: The flutter doctor command is still your best friend. It gives you a clear checklist of what's working and what needs attention across the Flutter SDK, Android Studio, Xcode, and connected devices.
• Integrated IDEs: Setting up your code editor—whether it's Visual Studio Code or Android Studio—with the right Flutter and Dart extensions is now a core part of the process. This is what unlocks game-changing features like hot reload and intelligent code completion.

This guide will walk you through these modern steps, making sure you understand not just how to install Flutter, but why each piece of the puzzle is so important for a productive workflow.

Preparing Your System for a Smooth Installation

Before you even think about downloading the Flutter SDK, let's talk about prep work. I've seen countless developers—new and seasoned—get tripped up by simple setup issues that could have been avoided. Taking a few minutes to get your system ready will save you hours of headaches later. Trust me.

First things first: disk space. The Flutter SDK itself is pretty lean, but its companions aren't. You’ll need the native build tools, emulators, and IDEs, which add up quickly. I’d say 10 GB is the absolute minimum, but you'll be much happier with 20 GB or more. This gives you enough breathing room for multiple SDK versions and virtual devices without constantly fighting storage warnings.

Next up, and this is non-negotiable, you need Git. The Flutter framework is managed as a Git repository, so you absolutely must have it installed and accessible from your command line. If you don't have it, go grab it now.

Operating System and Core Dependencies

Your OS version is the foundation of a stable Flutter environment. The Flutter team is specific about these requirements for a reason—they ensure the underlying native build tools will play nicely.

• Windows: You'll need a 64-bit version of Windows 10 or later, specifically version 22H2 or newer.
• macOS: Your machine should be running macOS 13 (Ventura) or a more recent version.
• Linux: Any modern 64-bit distro will do, but a baseline like Ubuntu 22.04 LTS is a safe bet.

These aren't just polite suggestions. In my experience, trying to work around them is the fastest way to a broken setup. The good news is that most developers are already on a compatible system. A 2026 Stack Overflow survey found that 89% of professional developers in the US already meet these OS requirements.

Pro Tip: Before you start installing anything new, run your system's software update one last time. It’s a simple step, but ensuring all your system libraries are current can prevent a whole class of dependency conflicts right from the start.

Platform-Specific Tooling You Cannot Skip

This is the part that trips up most newcomers. Just installing the Flutter SDK isn't enough. You have to install the native build tools for any platform you want to build for—be it Android, iOS, or desktop.

We're also seeing a shift in what developers are targeting. A 2025 report showed that only 30% of developers are exclusively building for iOS and Android anymore. Desktop, especially Linux, is gaining traction, with Flutter builds for Linux now making up 11.2% of the total. To get a handle on this trend, you can learn more about the current demand for Flutter developers at Cloudoora.com.

For Linux Desktop Developers

If you're aiming to build desktop apps on Linux, you'll need a handful of development libraries. On a Debian-based system like Ubuntu, you can install them all in one go with a single command:

sudo apt-get install clang cmake ninja-build pkg-config libgtk-3-dev

These packages give you the C++ compiler (clang), the build system (CMake and Ninja), and the GTK libraries Flutter relies on to render your app's UI on Linux.

For macOS and iOS Developers

On a Mac, your world revolves around Xcode. You need to install it from the App Store, but just downloading it won't cut it. There are a few crucial follow-up steps:

1. Open Xcode at least once. This is essential, as it prompts you to accept the license agreement and installs some critical command-line components in the background.
2. Point your system to the right tools. Run sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer in your terminal. This command tells Flutter where to find the command-line tools it needs.
3. Install CocoaPods. This is the dependency manager for iOS and macOS projects. The command sudo gem install cocoapods will get it done. You'll want to be on version 1.15+ to avoid a lot of common integration headaches.

Getting these prerequisites right is easily the most important part of the entire installation. It's the difference between a flutter doctor command full of green checkmarks and an evening spent hunting down solutions to cryptic error messages. For a deeper dive into the other tools you should have, check out our guide on essential Flutter development tools for 2024.

Alright, with the prep work out of the way, it's time to get the Flutter SDK onto your machine. The exact steps will depend on your operating system, but thankfully, things have gotten a lot easier. We've moved past the days of manually downloading ZIP files and wrestling with environment variables.

The whole setup process really boils down to three key stages: getting your OS ready, making sure you have enough disk space, and then installing the right tools.

Thinking about installation this way—as a sequence rather than a single command—is the key to avoiding headaches down the road.

Flutter's growth on desktop is a big reason why installation has become so refined. By mid-2025, data showed developers were heavily invested in desktop targets, with 24.1% building for macOS, 20.1% for Windows, and 11.2% for Linux. This isn't just a mobile framework anymore.

To support this, the installation tools have become incredibly reliable. The universal command for Unix-like systems now has a 98% success rate, and on the Windows side, winget has been a massive win. Adoption of the winget install --id Google.Flutter command has skyrocketed, now used by 35% of developers in major U.S. tech hubs like Austin. You can dig into more of these trends and see how flutter doctor now auto-fixes 87% of common issues in the State of Flutter 2026 report on devnewsletter.com.

Flutter Installation Commands by Operating System

To get you started quickly, here's a quick-reference guide to the primary installation commands for Windows, macOS, and Linux. Find your OS and use the recommended command to get the Flutter SDK.

These commands are your entry point. Once the SDK is in place, you'll just need to configure your environment and run flutter doctor to confirm everything is connected.

How To Install Flutter on Windows With Winget

For anyone on Windows, the Windows Package Manager, better known as Winget, is your best friend. It automates the entire process—downloading, unzipping, and adding Flutter to your system PATH—all in a single command. This completely removes the risk of manual errors.

Just pop open a PowerShell terminal and run this:

winget install --id Google.Flutter

Winget will pull the official Flutter package directly from Google's repository and set it up. After it finishes, it's a good habit to close and reopen your PowerShell window. This forces it to recognize the newly updated PATH variable. From there, flutter doctor will tell you if you're good to go.

I can't overstate how much of a game-changer Winget is for Windows developers. It turns a multi-step, error-prone process into a single, reliable command. It's the method I recommend to all Windows users today.

How To Install Flutter on macOS and Linux

On macOS and Linux, the installation is just as streamlined, though it involves one quick manual tweak to make the flutter command available everywhere. You’ll start by using a standard curl command to download and run the installation script.

Open your terminal and execute this line:

curl -fsSL https://flutter.dev/install | bash

This command safely downloads the installer from flutter.dev and executes it. The script clones the Flutter SDK directly into your home directory, placing it at ~/flutter.

The final and most important step is to permanently add Flutter to your shell's PATH. The script actually tells you the exact line to add, which will look like this:

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

You just need to add this line to the end of your shell's configuration file.

• For macOS (Catalina or newer): Your shell is most likely Zsh, so the file is .zshrc. You can edit it by running nano ~/.zshrc.
• For Linux (and older macOS): You're probably using Bash, so the file will be .bash_profile or .bashrc. Use nano ~/.bashrc to edit it.

After pasting the line and saving the file, just close and reopen your terminal. The flutter command will now work from any directory. Run flutter doctor as your final check; it’s perfect for spotting any remaining setup issues with your Android or iOS toolchains.

Configuring Your IDE and Running Your First App

Getting the Flutter SDK onto your machine is a great first step, but the real magic happens inside your Integrated Development Environment (IDE). This is your digital workshop—where you’ll write code, hunt down bugs, and leverage Flutter's famous features like hot reload. Without a properly configured IDE, you just have a set of command-line tools. With one, you have a development powerhouse.

Most Flutter developers use either Visual Studio Code or Android Studio. Here's the key thing to remember: even if you prefer writing code in the lightweight and zippy VS Code, you must have Android Studio installed. Flutter depends on it for the Android SDK, build tools, and the virtual device manager. A lot of seasoned developers actually use both—Android Studio for its robust Android device management and VS Code for day-to-day coding.

Must-Have Extensions for Your IDE

To really get your IDE working for you, you'll need to install a couple of essential plugins. In both VS Code and Android Studio, this is as simple as heading to the extensions or plugins marketplace and searching for "Flutter."

When you install the Flutter extension, it also brings along its counterpart, the Dart plugin, since Flutter apps are written in the Dart language. These two plugins are what light up your editor, giving you:

• Intelligent Code Completion: Get smart, context-aware suggestions as you type.
• Widget Inspection: Visually explore your UI tree, which is a lifesaver for debugging complex layouts.
• Hot Reload & Hot Restart: See your changes reflected in the app in less than a second without losing your state.

This instant feedback is the heart of the Flutter development experience. It makes building and iterating on UIs incredibly fast and genuinely enjoyable.

Don't think of these extensions as optional add-ons. They are fundamental to a productive workflow. Coding Flutter without them is like trying to build furniture without a tape measure or a saw—you're missing the core tools that make the job efficient.

Setting Up Your First Virtual Device

Your code needs a place to run, whether that's a physical phone you plug in or a virtual one running on your computer. We call these virtual devices emulators (for Android) or simulators (for iOS). Let’s fire up an Android emulator using the tools that came with your Android Studio installation.

First, open Android Studio and find the Device Manager, which is usually an icon in the top-right toolbar or under the Tools menu. From there:

• Click Create device to start the wizard.
• Choose a phone hardware profile you like—a recent Pixel model is always a safe bet—and click Next.
• Now, select a system image. Pick a recent API level that includes Google APIs. You might have to click the download icon next to it if you don't have it locally.
• Finally, give your new virtual device a name and click Finish.

You can now launch your emulator directly from the Device Manager. If you're on a Mac with Xcode installed, you already have an iOS Simulator ready to go. Just search for "Simulator" in Spotlight and open it.

Creating and Running Your First Project

With your IDE configured and an emulator booted up, you’re ready for the final step. It's time to create and run your very first Flutter project.

Open your terminal or command prompt, move to a folder where you keep your projects, and run this command:

flutter create my_app

This single command scaffolds a complete, functional Flutter app inside a new my_app folder. It’s the classic counter app you see in every demo, and it's a perfect starting point. You can find a more in-depth look at this part of the process in our guide to Flutter installation in Android Studio.

Next, change into your new project's directory:

cd my_app

With your emulator running or a physical device connected, run this final command:

flutter run

The very first build will take a minute or two as it compiles the native platform code. But after that, you'll witness the power of hot reload. Make a change in your code, save it, and watch the app update almost instantly. You've just gone from zero to a running Flutter app—now you’re all set to start building.

Advanced Setup and Professional Best Practices

Getting Flutter installed is one thing, but setting it up for professional team development is another ballgame entirely. When you move past solo projects and start collaborating, you need a workflow that’s predictable, scalable, and won't fall apart when someone on the team updates their tools.

The standard flutter upgrade command, while simple, can become a real headache in a team environment. Picture this: one developer on your team upgrades to the latest Flutter release to experiment with a new feature. Suddenly, their code introduces breaking changes or subtle bugs that only appear on their machine, while the rest of the team is left scratching their heads over build failures. This is a classic "it works on my machine" scenario, and it can bring productivity to a grinding halt.

Taming Complexity with a Version Manager

This is precisely the problem that the Flutter Version Manager (FVM) was built to solve. FVM lets you install and manage multiple versions of the Flutter SDK on a single computer. More importantly, it allows you to lock a specific SDK version to each of your projects.

This means you can keep that legacy app running on Flutter 2.8 while starting a brand-new project on the latest stable release. No more conflicts, no more guesswork.

Using a version manager like FVM isn't just a nice-to-have; it's a non-negotiable best practice for any serious Flutter project. It guarantees that every developer—and your CI/CD pipeline—is building with the exact same SDK version. This alone eliminates an entire category of environment-related bugs.

Getting started with FVM is simple. You can install it globally using Dart's own package manager, pub:

dart pub global activate fvm

Once it's installed, you'll primarily use a few key commands within your project directory:

• To install a specific Flutter version: fvm install 3.19.0
• To set your project to use that version: fvm use 3.19.0

Running fvm use creates a special .fvm folder in your project that points to the correct SDK version. When you commit this configuration to your repository, anyone who clones the project can get up and running on the right version instantly.

Configuring for CI/CD Pipelines

A truly professional setup doesn't stop at your local machine. Your automated workflows, like those in GitHub Actions, also need to be pinned to the correct Flutter version to ensure reliable builds and deployments.

Thankfully, integrating FVM into a CI/CD pipeline is incredibly easy. A typical workflow file for GitHub Actions would just need a few extra lines in its setup script:

• First, ensure FVM is available by running dart pub global activate fvm.
• Then, instead of manually specifying a version, just run fvm install. This command cleverly reads your project's FVM configuration and grabs the exact SDK you need.
• From that point on, simply prefix all your Flutter commands with fvm, like fvm flutter test or fvm flutter build apk.

This approach ensures your automated builds happen in an environment that perfectly mirrors every developer's local setup. It makes your deployment process far more robust and predictable. By adopting these practices, you're not just installing Flutter; you're building a solid, enterprise-grade foundation for all your projects to come.

Common Flutter Installation Questions Answered

So you’ve followed the docs, but a cryptic error message just stopped you in your tracks. It happens. Even with modern tooling, getting Flutter set up perfectly the first time can have a few bumps.

Let’s walk through the most common snags people hit during installation. This isn't just about copy-pasting commands; it's about understanding why these problems happen so you can fix them for good.

What Do I Do If the 'flutter' Command Is Not Recognized?

This is the classic rite of passage for new Flutter developers. You’ve downloaded the SDK, you pop open a new terminal, type flutter, and… command not found. Don't worry, we've all been there. This almost always means your system’s PATH variable isn't pointing to the right place.

The PATH is just a list of directories your command line searches when you run a command. If the folder containing Flutter’s tools isn’t on that list, your computer has no idea where to look.

Here’s the quick way to diagnose and fix it:

• Confirm It's a PATH Issue: First, try running the command with its full, absolute path. On macOS or Linux, that might look like ~/flutter/bin/flutter doctor. If that works, you’ve confirmed the SDK is fine and the problem is 100% the PATH.
• Fixing the PATH on macOS/Linux: You'll need to edit your shell's startup file. For most modern setups (including recent macOS versions), this is .zshrc. Open it with nano ~/.zshrc and add this line: export PATH="$HOME/flutter/bin:$PATH". If you're on an older system using Bash, you'll edit ~/.bashrc or ~/.bash_profile instead.
• Fixing the PATH on Windows: Search for "Edit the system environment variables" from the Start Menu. In the window that pops up, click "Environment Variables," find "Path" under "User variables," and click "Edit." You need to add a new entry that points directly to your Flutter bin folder, like C:flutterbin.

Remember to close and reopen your terminal or PowerShell window after making changes. That’s how the new PATH settings get loaded.

How Can I Install an Older Flutter Version for a Legacy Project?

In the real world, you don't always get to work with the latest and greatest. You'll inevitably join a project that's pinned to an older Flutter version. Trying to swap out your main Flutter SDK manually is a fast track to headaches and broken projects.

The industry-standard tool for this is the Flutter Version Manager (FVM). It lets you install multiple Flutter versions and switch between them on a per-project basis. Frankly, this is a non-negotiable tool for any professional Flutter developer.

Getting started with FVM is incredibly simple. First, you'll install it globally:

dart pub global activate fvm

Then, from inside your project's main directory, you can tell it which version to use. For example, if your project needs version 3.16.9:

• First, install that specific version: fvm install 3.16.9
• Then, tell the project to use it: fvm use 3.16.9

From that point on, you just prefix your usual Flutter commands with fvm (like fvm flutter run or fvm flutter pub get), and it will automatically use the correct SDK version for that specific project. No more manual switching.

How Do I Fix Android Toolchain or License Issues?

Seeing the [✗] Android toolchain - develop for Android devices warning from flutter doctor can feel intimidating, but the fix is usually right in front of you. This error means Flutter can't properly talk to the Android SDK, and more often than not, it's because you haven't accepted the necessary licenses.

The solution is almost always the one flutter doctor itself suggests. Run this command in your terminal:

flutter doctor --android-licenses

This starts a little interactive script that will ask you to review and accept a series of licenses. Just type y and hit Enter for each one until it's done.

Occasionally, the problem is that Flutter can't find your Android SDK at all, especially if you installed Android Studio in a custom location. You can fix this by telling Flutter exactly where to look:

flutter config --android-sdk /path/to/your/sdk

Run flutter doctor again after trying these fixes. You should be greeted with a satisfying green checkmark next to the Android toolchain.

Do I Need Both Android Studio and VS Code?

This question comes up a lot. Here's the simple answer: you don't need to code in both, but you absolutely must have Android Studio installed.

Think of Android Studio as the backend engine for all Android development. Flutter relies on it for several critical components that it installs and manages:

• The core Android SDK.
• The native build tools needed to compile an Android app.
• The Android Virtual Device (AVD) Manager, which you use to create emulators.

Even if you never open the editor, these tools are essential. A very common and productive workflow is to use Android Studio just for managing SDK updates and emulators, while doing all of your actual coding in the much lighter and faster Visual Studio Code. With its fantastic Flutter and Dart extensions, this setup gives you the best of both worlds.

At Flutter Geek Hub, we're committed to providing the most practical and up-to-date guides to help you master every aspect of Flutter development. From installation troubleshooting to advanced architecture, you'll find the resources you need to build with confidence. Explore more deep-dive tutorials and best practices at https://fluttergeekhub.com.