# How to Run Flutter App in VS Code on Linux: Complete Android Development Guide

> Learn to run your Flutter app in VS Code on Linux with this complete guide. Connect your Android device via USB and debug seamlessly. Start building cross-platform apps today.

- Repository: [Flutter/flutter](https://github.com/flutter/flutter)
- Tags: how-to-guide
- Published: 2026-02-16

---

**You can run a Flutter app in VS Code on Linux by installing the Flutter SDK, configuring the Android SDK with ADB, installing the Flutter and Dart VS Code extensions, connecting your Android device via USB with debugging enabled, and pressing F5 to launch the debugger.**

To run a Flutter app in VS Code on Linux with a physical Android device, you need to configure the Flutter toolchain, Android Debug Bridge (ADB), and IDE extensions. This guide references the `flutter/flutter` repository to show you the exact file paths and configurations required to build, deploy, and debug Flutter applications on Linux workstations.

## Prerequisites

### Install Flutter SDK on Linux

The Flutter SDK contains the `flutter` command-line tool, the Dart SDK, and platform-specific binaries that drive the Android toolchain. After extracting the SDK, add its `bin` directory to your `PATH` so that `flutter` can be invoked from any terminal.

```bash

# Extract Flutter SDK

tar xf flutter_linux_3.x.x-stable.tar.xz
export PATH="$PATH:`pwd`/flutter/bin"

# Verify installation

flutter doctor

```

The `flutter` CLI script located at `bin/flutter` in the SDK root orchestrates the build process, device detection, and deployment.

### Configure Android SDK and ADB

Android Studio's SDK manager provides `adb`, the Android Debug Bridge. With USB debugging enabled on your phone and the device authorized, `adb devices` lists the phone, allowing the Flutter tool to discover it as a target device.

```bash

# Verify device connection

adb devices

# Expected output:

# List of devices attached

# ABC123DEF456    device

```

## Configure VS Code for Flutter Development

### Install Flutter and Dart Extensions

The **Flutter** and **Dart** extensions add language support, debugging integration, and commands such as **Flutter: Launch Emulator** and **Flutter: Run Without Debugging** that internally invoke the `flutter` CLI.

Install these extensions from the VS Code marketplace:
- Dart (dart-code.dart-code)
- Flutter (dart-code.flutter)

### Set Up Launch Configuration

VS Code stores run and debug settings in [`.vscode/launch.json`](https://github.com/flutter/flutter/blob/main/.vscode/launch.json). A standard Flutter configuration tells VS Code to start `flutter run` for the currently opened folder and attach the Dart VM debugger.

```json
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Flutter",
      "request": "launch",
      "type": "dart"
    }
  ]
}

```

For a specific device, add the `deviceId` parameter using the ID from `flutter devices`:

```json
{
  "configurations": [
    {
      "name": "Flutter on MyPhone",
      "request": "launch",
      "type": "dart",
      "deviceId": "ABC123DEF456"
    }
  ]
}

```

## Connect Your Android Device

Before you run the Flutter app in VS Code on Linux, ensure your Android device is properly configured:

1. Enable **Developer Options** on your Android device (tap Build Number seven times in Settings > About Phone).
2. Enable **USB Debugging** in Developer Options.
3. Connect the device via USB and authorize the debugging connection when prompted.
4. Verify connectivity with `adb devices` in your terminal.

On Linux, you may need to configure udev rules to allow non-root access to the Android device. Create `/etc/udev/rules.d/51-android.rules` with your device's vendor ID:

```bash

# Example for Google devices

SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"

```

Then reload the rules:

```bash
sudo udevadm control --reload-rules
sudo udevadm trigger

```

## Run Flutter App in VS Code on Linux

### Using F5 Debug Mode

With the device connected and the Flutter project open, press **F5** (or click the green Run button). VS Code reads [`.vscode/launch.json`](https://github.com/flutter/flutter/blob/main/.vscode/launch.json) and runs `flutter run` in debug mode, attaching the Dart VM debugger to provide breakpoints and inspection tools.

The Flutter tool builds the Android APK using the Gradle configuration in `android/gradle.properties` and `packages/flutter_tools/gradle/flutter.gradle`, pushes it to the device via `adb`, installs it, and starts the Dart VM with a debugging port.

### Run Without Debugging

Use the Command Palette (**Ctrl+Shift+P**) and select **Flutter: Run Without Debugging**. This launches `flutter run` in release mode, providing better performance but no debugging capabilities.

### Terminal Commands

Open a terminal inside VS Code (**Ctrl+``**) and execute `flutter run` manually. This is useful for passing extra flags such as `--flavor`, `--target`, or `--dart-define`:

```bash

# Run with a specific flavor

flutter run --flavor development

# Run with environment variables

flutter run --dart-define=API_KEY=12345

```

## Hot Reload and Hot Restart

While the app is running, you can update code instantly without losing app state.

Press **`r`** in the integrated terminal where `flutter run` is active, or click the **⟳** "Hot Reload" button in VS Code. This triggers a quick code push that updates the UI without a full restart.

Press **`R`** (capital R) or click the **⭮** "Hot Restart" button to perform a hot restart, which reinitializes the app's state but is faster than a full rebuild and reinstall.

## Troubleshooting Common Issues

### Device Not Listed

If `flutter devices` or `adb devices` does not show your Android phone, ensure the device is unlocked, USB debugging is enabled, and the USB connection is authorized. Run `adb kill-server && adb start-server` to restart the ADB daemon.

### Permission Errors on Linux

If you encounter "no permissions" errors when running `adb devices`, your user likely lacks access to the USB device. Add a udev rule in `/etc/udev/rules.d/51-android.rules` with your device's vendor ID, set the mode to `0666`, and reload the rules with `udevadm control --reload-rules`.

### Missing Android Toolchain

Run `flutter doctor` to identify missing components such as `adb`, `Android SDK Platform-Tools`, or Android licenses. Install missing components via Android Studio's SDK Manager or the command-line tools, then run `flutter doctor --android-licenses` to accept the SDK licenses.

## Summary

- **Install the Flutter SDK** on Linux by extracting the archive and adding the `bin` directory to your `PATH`, then verify with `flutter doctor`.
- **Configure Android SDK and ADB** to enable USB debugging on your physical device and ensure `adb devices` lists the phone.
- **Install VS Code extensions** for Flutter and Dart to enable debugging integration and Flutter-specific commands.
- **Create [`.vscode/launch.json`](https://github.com/flutter/flutter/blob/main/.vscode/launch.json)** with a `dart` type configuration to define how VS Code launches `flutter run`.
- **Run the app** by pressing F5 for debugging, using the Command Palette for release mode, or executing `flutter run` in the terminal.
- **Use hot reload** (`r`) and hot restart (`R`) to update code instantly without full rebuilds.
- **Troubleshoot** device detection, permissions, and toolchain issues using `flutter doctor` and udev rules.

## Frequently Asked Questions

### How do I fix "device not found" when running Flutter in VS Code on Linux?

Ensure USB debugging is enabled on your Android device and that you have authorized the computer on the phone's popup dialog. Run `adb devices` in your terminal to verify the connection. If the device appears as "unauthorized," disconnect and reconnect the USB cable to trigger the authorization dialog again.

### Can I run Flutter apps in VS Code without installing Android Studio?

Yes, you can use the command-line Android SDK tools instead of the full Android Studio IDE. Download the command-line tools from Android's developer site, extract them, and set the `ANDROID_SDK_ROOT` environment variable. Run `flutter doctor` to verify the Android toolchain is detected, then install the platform tools and accept licenses using `sdkmanager`.

### Why does my Linux machine require sudo to detect my Android device?

Linux requires udev rules to grant non-root users access to USB devices. Without these rules, `adb` cannot communicate with the phone unless run with elevated privileges. Create a file at `/etc/udev/rules.d/51-android.rules` containing a rule with your device's vendor ID (found via `lsusb`), set the permissions to `0666`, and reload the udev rules to resolve this.

### How do I specify a particular Android device when multiple are connected?

When multiple devices are connected, VS Code will prompt you to select a target, or you can specify the device ID in your [`.vscode/launch.json`](https://github.com/flutter/flutter/blob/main/.vscode/launch.json) configuration. Add the `"deviceId"` property with the value from `flutter devices` output (e.g., `"deviceId": "HTC1234567890"`). Alternatively, use the terminal command `flutter run -d <device_id>` to target a specific device directly.