Flutter Wake Word Detection: Complete Tutorial (2026)

Flutter doesn't offer built-in wake word detection, requiring a third-party package. While there are options, most aren't production-ready. They use open-source runtimes like ONNX and PyTorch, which are designed for server inference, or legacy technologies that require days, if not weeks, to train custom wake words. These trade-offs compromise UX and device performance, such as battery life. This tutorial demonstrates how to implement wake word detection in Flutter using Porcupine Wake Word, an enterprise-grade, lightweight engine optimized for production deployments.

Choosing a Wake Word Solution for Flutter

Porcupine is a top choice for Flutter wake word detection because it:

• Runs entirely on-device: audio never leaves the device—no network calls means lower latency and no privacy concerns about sending voice data to external servers.
• Supports custom wake words: easily train your own keywords using the Picovoice Console. Simply type in your keyword and click "Train"—done in seconds.
• Built-in keywords available: if you don't need a custom wake word, you can also skip the training step entirely and use one of the available built-in keywords.
• Is optimized for mobile: lightweight models (typically <10KB per keyword) with minimal CPU usage, ideal for iOS and Android devices.
• Is production-ready: actively maintained, with regular updates and proven reliability in apps with millions of installs.

This guide walks through implementing wake word detection in Flutter using Porcupine Wake Word—a fully on-device solution that runs keyword detection locally. We'll cover installation, custom wake word training, and production implementation that runs on both iOS and Android.

Step-by-Step: Wake Word Detection in Flutter

This tutorial shows you how to add wake word detection to your Flutter app using Porcupine Wake Word. You'll learn to set up offline voice activation that works on both iOS and Android.

Prerequisites for Flutter Wake Word Integration

• Flutter SDK (2.8.1+)
• Android SDK (21+)
• JDK (11+)
• Xcode (13+)

Step 1: Install Flutter Wake Word Dependencies

Add the flutter_voice_processor and porcupine_flutter plugins to your project's pubspec.yaml:

dependencies:
  flutter_voice_processor: ^{LATEST_VERSION}
  porcupine_flutter: ^{LATEST_VERSION}

Step 2: Train Your Custom Wake Word Model

Create a Picovoice Console account and train a custom keyword. This lets you create branded wake words like "Hey [YourApp]" instead of generic phrases.

Useful guides:

• Written guide: Choosing a Wake Word
• Video walkthrough: Picovoice Console Tutorial: Porcupine Wake Word

Once you have chosen your keyword, download the keyword files. You will need to download two keyword files—one for Android, and one for iOS. The files will have a .ppn extension.

Step 3: Add Wake Word Files to Your Flutter Project

Place the downloaded keyword files into your project's assets/ folder and reference them in pubspec.yaml:

flutter:
  assets:
    - assets/${KEYWORD_FILE_ANDROID} # e.g. assets/bumblebee_android.ppn
    - assets/${KEYWORD_FILE_IOS} # e.g. assets/bumblebee_ios.ppn

Using Non-English Wake Words: If you created a non-English keyword, you will also need to add the corresponding model file for the language you chose. Also place the model file into your project's assets/ folder and reference them in pubspec.yaml:

flutter:
  assets:
    # ...
    - assets/${MODEL_FILE} # e.g. assets/porcupine_params_de.pv

Step 4: Configure Microphone Permissions

iOS Setup

In Info.plist:

<key>NSMicrophoneUsageDescription</key>
<string>Your app needs microphone access for wake word detection.</string>

Android Setup

In AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />

Step 5: Define Wake Word Detection Callback Function

Define a function to handle keyword detection. You can pass in more than one keyword when initializing Porcupine (see next step), and the detection callback function will give you the index of the keyword detected.

void _detectionCallback(int keywordIndex) {
  if (keywordIndex == 0) {
    print('Keyword detected');
  }
}

Step 6: Initialize the Flutter Wake Word Engine

Copy your AccessKey from the Picovoice Console. The AccessKey is only required for authentication and authorization.

Create an instance of PorcupineManager. Replace {ACCESS_KEY} with your Picovoice AccessKey, keywordPath and modelPath with the correct paths, and pass in your _detectionCallback() function.

// import 'dart:io';
import 'package:porcupine_flutter/porcupine_manager.dart';

PorcupineManager? _porcupineManager;

// var platform = (Platform.isAndroid) ? "android" : "ios";
var keywordPath =
    "assets/{KEYWORD_FILE}"; // e.g. "assets/blueberry_$platform.ppn";
_porcupineManager = await PorcupineManager.fromKeywordPaths(
  "{ACCESS_KEY}",
  [keywordPath],
  _detectionCallback,
  modelPath: "assets/{MODEL_FILE}", // (if non-English keyword)
);

Step 7: Start and Stop Wake Word Listening

To start listening for wake words:

await _porcupineManager?.start();

To stop listening for wake words:

await _porcupineManager?.stop();

Step 8: Clean Up Wake Word Resources

Once you no longer need PorcupineManager, release the resources acquired:

await _porcupineManager?.delete();

Complete Flutter Wake Word Code Example

Below is a fully implemented widget you can add to your project to see Porcupine in action. Replace '{ACCESS_KEY}' with your own AccessKey from Picovoice Console, '{KEYWORD_FILE}' with your keyword file, and '{MODEL_FILE}' with your model file (if applicable).

import 'dart:io';

import 'package:flutter/material.dart';
import 'package:porcupine_flutter/porcupine_manager.dart';
import 'package:porcupine_flutter/porcupine_error.dart';

enum AppState { initial, loading, ready, listening }

class PorcupineWidget extends StatefulWidget {
  const PorcupineWidget({super.key});

  @override
  State<PorcupineWidget> createState() => _PorcupineWidgetState();
}

class _PorcupineWidgetState extends State<PorcupineWidget> {
  PorcupineManager? _porcupineManager;
  AppState _appState = AppState.initial;

  // Handle detected keywords
  void _detectionCallback(int keywordIndex) {
    if (keywordIndex == 0) {
      print('Keyword detected');
    }
  }

  void _processErrorCallback(PorcupineException err) {
    print('Porcupine error: ${err.message}');
  }

  // 1. Initialize Porcupine
  Future<void> _init() async {
    setState(() => _appState = AppState.loading);

    if (_porcupineManager == null) {
      try {
        var platform = (Platform.isAndroid) ? "android" : "ios";
        var keywordPath =
            "assets/{KEYWORD_FILE}"; // e.g. "assets/blueberry_$platform.ppn";
        _porcupineManager = await PorcupineManager.fromKeywordPaths(
          "{ACCESS_KEY}",
          [keywordPath],
          _detectionCallback,
          errorCallback: _processErrorCallback,
          // modelPath: "assets/{MODEL_FILE}", // (if non-English keyword)
        );

        setState(() => _appState = AppState.ready);
      } on PorcupineException catch (err) {
        print('Porcupine initialization failed: ${err.message}');
        setState(() => _appState = AppState.initial);
      }
    }
  }

  // 2. Start listening for keywords
  Future<void> _start() async {
    if (_porcupineManager == null) return;
    setState(() => _appState = AppState.loading);

    try {
      await _porcupineManager?.start();
      setState(() => _appState = AppState.listening);
    } on PorcupineException catch (err) {
      print('Error starting voice processor: ${err.message}');
      setState(() => _appState = AppState.ready);
    }
  }

  // 3. Stop listening for keywords
  Future<void> _stop() async {
    setState(() => _appState = AppState.loading);

    try {
      await _porcupineManager?.stop();
      setState(() => _appState = AppState.ready);
    } on PorcupineException catch (err) {
      print('Error stopping voice processor: ${err.message}');
      setState(() => _appState = AppState.listening);
    }
  }

  // 4. Clean up resources
  Future<void> _delete() async {
    setState(() => _appState = AppState.loading);

    await _stop();

    await _porcupineManager?.delete();
    _porcupineManager = null;

    setState(() => _appState = AppState.initial);
  }

  @override
  void dispose() {
    _porcupineManager?.delete();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        ElevatedButton(
          onPressed: _appState == AppState.initial ? _init : null,
          child: const Text('Init'),
        ),
        ElevatedButton(
          onPressed: _appState == AppState.ready ? _start : null,
          child: const Text('Start'),
        ),
        ElevatedButton(
          onPressed: _appState == AppState.listening ? _stop : null,
          child: const Text('Stop'),
        ),
        ElevatedButton(
          onPressed: _appState == AppState.ready ? _delete : null,
          child: const Text('Delete'),
        ),
      ],
    );
  }
}

This is a simplified example but includes all the essential code to get you started. For a complete working app, check out the Porcupine Flutter demo on our GitHub repository.

Optimizing Wake Word Detection Accuracy

To get the best wake word detection results in your Flutter app:

1. Choose distinctive wake words: Avoid common phrases that might trigger false positives
2. Test in realistic conditions: Test with background noise, different accents, and varying distances
3. Use sensitivity tuning: Adjust Porcupine's sensitivity parameter to balance accuracy and responsiveness
4. Handle multiple keywords: Implement different actions for different wake words in the same app

Advanced Flutter Wake Word Integration

Using Multiple Wake Words Simultaneously

You can detect multiple wake words at once by passing an array of keyword paths:

var keywordPaths = [
  "assets/hey_app_$platform.ppn",
  "assets/stop_$platform.ppn",
  "assets/help_$platform.ppn"
];

_porcupineManager = await PorcupineManager.fromKeywordPaths(
  "{ACCESS_KEY}",
  keywordPaths,
  _detectionCallback,
);

Integrating Wake Word with Voice Commands

Combine wake word detection with Rhino Speech-to-Intent to create a complete voice interface. After detecting a wake word, activate speech recognition to process the user's command.

Flutter Wake Word Resources & Documentation

This tutorial uses the following packages:

• porcupine_flutter - Official Porcupine Flutter package
• flutter_voice_processor - Audio processing utilities

Additional documentation & resources:

• Porcupine Wake Word Quick Start
• Porcupine Wake Word API
• GitHub Flutter Wake Word Demo App

Conclusion: Building Production-Ready Flutter Wake Word Apps

With Porcupine and Flutter, you can build offline voice-activated applications that work reliably on both Android and iOS. Whether you're building accessibility tools, hands-free interfaces, or voice-controlled hardware, this guide gives you everything you need to integrate accurate wake-word detection into your app.

Unlike many alternatives, Porcupine provides a production-ready, actively maintained solution with custom wake word training, multi-language support, and proven mobile performance.

Frequently Asked Questions About Flutter Wake Word Detection