Getting started with Flutter on a Mac

Build and publish a Flutter-based app for the App Store and Google Play — updated for 2026 with current tooling, current hardware, and current best practices.

Follow along to learn everything you need to set up your environment, build a Flutter-based app, put it into source control, and publish it to the App Store and Google Play. Along the way you will need some third-party tools and services. The ones used here are chosen to be the simplest viable set, but you are free to make other choices. We have published hundreds of apps for both stores and will cover wider topics around publication and ongoing distribution. One of those topics — licenses — appears in this very first article. Don't skip it.

TL:DR – Start here. Get all the tools required and build your first mobile app using Flutter on a Mac with Apple silicon. Every Mac Apple sells today runs Apple silicon, and Flutter's toolchain in 2026 reflects that reality.

What's changed in 2026

A lot has moved since this article was first written. The headline change that will matter most to anyone who has tried Flutter on Apple silicon before: Flutter no longer requires Rosetta 2. That long-standing friction point — tracked across several GitHub issues for years — has finally been resolved. Native ARM64 execution is now the default on Apple silicon Macs, and you no longer need to run sudo softwareupdate --install-rosetta --agree-to-license as part of your setup.

The other significant shift is in editor recommendation. While Android Studio remains a fully supported and capable choice, the Flutter team and the wider community have moved toward Visual Studio Code ( or VSCodium) as the recommended editor for Flutter development. It is free, fast, cross-platform, and the Flutter and Dart plugins for are actively maintained and feature-complete. This article covers both options, but the setup steps below lead with VSCodium.

Flutter itself has matured considerably. The framework now targets iOS, Android, macOS, Windows, Linux, and the web from a single codebase — and that multi-platform promise is more solid than ever. The Dart SDK continues to be bundled with Flutter, so there is no separate Dart installation step.

Starter app

First things first: let's set up a Mac with all the tools needed to build the Flutter starter app. Doing this confirms your environment is correctly configured and gives you a clean, working starting point for your own application. The starter app runs on iOS, Android, macOS, and in a browser — all from the same source code. That is the core promise of Flutter, and it holds up.

The promise of cross-platform apps

One source to rule them all

Take a moment to appreciate what those screenshots represent. On the left is the Material Design demo app running on an iOS simulator; on the right, the same app running on Android. There is an elevated app bar with a background colour, a title centred on iOS and left-aligned on Android — each respecting the platform's own guidelines — a floating action button sitting comfortably above the content, and clean, centred body text. These are completely different operating systems on completely different devices. The app runs from a single shared codebase. Later in this article you will see Chrome and macOS versions of the same app, again from exactly the same source. This is what Flutter delivers: one project, one language, one team, shipping everywhere.

Setup pre-requisites

You will need a Mac running a recent version of macOS. Apple has completed its transition to Apple silicon — every Mac sold today uses it — so this guide is written entirely for Apple silicon. If you are somehow still on an Intel Mac, the steps are broadly the same, but some of the performance observations will not apply.

To build for iOS and submit to the App Store you must use macOS, because Xcode is only licensed for macOS. Even if you primarily target Android, keeping iOS in your build and test cycle is one of the key advantages Flutter offers, so it is worth maintaining both from the start.

Step-by-step installation

• Install Xcode. Download Xcode from the Mac App Store. You need it to build for iOS and macOS, and Android Studio uses its command-line tools too. After installation, open Xcode once to accept the licence agreement and let it install additional components.
• Install Homebrew (recommended). The free, open-source package manager for macOS from brew.sh. You will almost certainly need it at some point, and installing it now avoids interruptions later.
• Download and install the Flutter SDK. Full, current instructions are maintained at docs.flutter.dev/get-started/install. The Dart SDK is bundled — you do not need to install it separately. Minimum disk space required is around 700 MB for the SDK itself, plus additional space for platform tools.
• Install your editor. The Flutter team recommends Visual Studio Code (free, cross-platform). Install the Flutter extension from the VS Code marketplace — it pulls in the Dart extension automatically. We recommend VSCodium, an open source rebuild of VS Code without Microsoft telemetry. If you prefer Android Studio, download it from developer.android.com, choose the Apple silicon build, and install the Flutter and Dart plugins from the Plugins screen.

  

  Welcome wizard

  

  Click Next to begin.

  Install type

  

  Select Standard and click Next.

  Select UI theme

  

  Pick a theme and click Next.

  Verify settings

  

  Confirm SDK and JDK paths and click Next.

  Licence agreement

  

  Select each licence, choose Agree, then click Finish.

  Downloading components

  

  Wait for the download to complete.

  Welcome screen

  

  Choose Plugins.

  Plugins

  

  Search for and install Flutter — Dart installs automatically.

• Install the Android command-line tools. These are not installed by the component download wizard. Download them from the Android Studio downloads page (scroll past the main download to find the command-line tools package). Extract the zip and move it into your Android SDK folder:
  mkdir -p ~/Library/Android/sdk/cmdline-tools; mv ~/Downloads/cmdline-tools ~/Library/Android/sdk/
  On a freshly set up Mac you may need to grant Terminal permission to access your Downloads folder before this command will succeed.
• Set up Java. Android Studio installs a bundled JDK. Linking to it is by far the simplest way to get a working JVM on a Mac — it updates automatically with Android Studio, and it is OpenJDK so there are no Oracle licence complications. Create the link with:
  sudo ln -s /Applications/Android\ Studio.app/Contents/jbr /Library/Java/JavaVirtualMachines/android-studio.jdk
  After that, /usr/libexec/java_home will resolve correctly. Verify with:

  % java --version
  openjdk 21 2024-09-17
  OpenJDK Runtime Environment (build 21+...)
  OpenJDK 64-Bit Server VM (build 21+..., mixed mode)

• Accept Android licences. Run flutter doctor --android-licenses and accept each prompt.
• Set your terminal path. Add the following to your shell profile (~/.zshrc on a default macOS setup):

  export ANDROID_HOME="$HOME/Library/Android/sdk"
  export PATH=$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/bin:$HOME/Development/flutter/bin:$HOME/.pub-cache/bin:$HOME/Development/flutter/bin/cache/dart-sdk/bin

  Adjust the Flutter SDK path to wherever you cloned or extracted it.
• Prepare devices and emulators. Real devices give the most realistic test experience and are required for some functionality. That said, the Android emulator running natively on Apple silicon is genuinely fast in 2026 — a far cry from the sluggish experience on Intel Macs. The iOS simulator on Apple silicon is equally responsive.

Checking your Flutter environment

Once the pre-requisites are in place, use flutter doctor to verify your environment and flutter upgrade to confirm you are on the latest stable release.

Run flutter upgrade first:

% flutter upgrade
Flutter is already up to date on channel stable
Flutter 3.x.x • channel stable • https://github.com/flutter/flutter.git
Framework • revision xxxxxxx
Engine • revision xxxxxxx
Tools • Dart 3.x.x

Then run flutter doctor. In 2026, on a properly configured Apple silicon Mac, you should see something close to this — with no Rosetta warning:

% flutter doctor
Doctor summary (to see all details, run flutter doctor -v):
[✓] Flutter (Channel stable, on macOS darwin-arm64)
[✓] Android toolchain - develop for Android devices (Android SDK version 35+)
[✓] Xcode - develop for iOS and macOS
[✓] Chrome - develop for the web
[✓] Android Studio
[✓] VS Code (with Flutter extension)
[✓] Connected device (3 available)
[✓] Network resources

• No issues found!

Work through any issues reported until Flutter doctor is fully green. The most common remaining stumbling block is CocoaPods — if it flags as missing, install it via Homebrew: brew install cocoapods. Once everything is clear, you are ready to create your first Flutter project.

Creating the app project

When you create the project, Flutter generates both an application ID (used by Android and Google Play) and a package name (your Dart code namespace, set in pubspec.yaml). They start out identical but are independent. The application ID lives in app/src/main/AndroidManifest.xml and must not be changed once your app binary has been published to any track in Google Play. Think carefully about your naming now. Changing it later is possible but not trivial. You can read the full detail at Configure the app module on developer.android.com.

Run flutter create nameofyourproject and the output will look similar to this:

flutter create nameofyourproject
Creating project nameofyourproject...
  nameofyourproject/lib/main.dart (created)
  nameofyourproject/pubspec.yaml (created)
  nameofyourproject/README.md (created)
  nameofyourproject/.gitignore (created)
  nameofyourproject/ios/Runner.xcodeproj/project.pbxproj (created)
  nameofyourproject/android/app/src/main/AndroidManifest.xml (created)
  nameofyourproject/test/widget_test.dart (created)
  ...
Running "flutter pub get" in nameofyourproject...
Wrote 77 files.

All done!

Running the app on all eligible devices

Confirm you have a device connected or an emulator running, then check what Flutter can see:

% flutter devices
4 connected devices:
sdk gphone64 arm64 (mobile)  • emulator-5554 • android-arm64  • Android 15 (API 35) (emulator)
iPhone 16 Pro (mobile)       • xxxxxxxx      • ios            • iOS 18 (simulator)
macOS (desktop)              • macos         • darwin-arm64   • macOS 15 Sequoia
Chrome (web)                 • chrome        • web-javascript • Google Chrome 1xx

Run the app on each target

• Android (physical device or emulator). Plug in a device or start the emulator, change into the project folder with cd nameofyourproject, then run: flutter run -d emulator-5554 (substitute the device ID reported by flutter devices).

  Running Gradle task 'assembleDebug'... Done
  ✓ Built build/app/outputs/apk/debug/app-debug.apk.
  Installing build/app/outputs/apk/debug/app-debug.apk...
  

  Or open the project in Android Studio or VS Code and press the Run button — on Apple silicon the emulator boots and runs at a speed that no longer feels like a compromise.

  

• iOS simulator. Launch the simulator with open -a Simulator — it will appear as a run target in both Android Studio and VS Code. Then run flutter run -d iPhone (or the full device ID). No Rosetta required.

Build and run for macOS

Run flutter run -d macos and Flutter builds a native Apple silicon binary. You can verify this yourself: right-click the built executable in Finder, choose Get Info, and confirm it says Kind: Application (Apple Silicon).

Build and run as a web app

Run flutter run -d chrome and Flutter builds and launches a web application. Note that Stateful Hot Reload is not supported for web targets — you will need to perform a full restart to see changes when developing for the web.

Publication pre-requisites

• Google Play. Sign in with your Google Account, accept the terms, pay the one-time registration fee, and complete your account details. Choose this Google Account carefully — it will be the permanent owner of your developer account, and losing access to it is a serious problem. There is no recovery path that doesn't involve Google support.
• Apple App Store. Enrol in the Apple Developer Program using an Apple ID with two-factor authentication enabled. You will need your legal name, address, and — if you are publishing as a business rather than an individual — your business details. Enroling as a business takes longer because Apple verifies the information. Do this now, not the week before you plan to launch.

References

• Flutter — Get started: Install — official installation documentation, always current
• Your first Flutter app — Google Codelabs walkthrough
• Configure the app module — Android developer documentation on application IDs
• Apple Developer Program enrolment