How to Implement Cross-Platform Voice Control in C

🎯 Voice AI Consulting

Get dedicated support and consultation to ensure your specific needs are met.

Building voice control into C applications requires real-time audio processing and consistent performance across Linux, Windows, macOS, and Raspberry Pi. Many developers use cloud-based solutions like Google Dialogflow, Amazon Lex, and IBM Watson—but all require sending audio to remote servers, introducing latency, connectivity dependencies, and privacy concerns.

For custom voice control in domain-specific applications, Speech-to-Intent offers a better approach. Instead of transcribing "Turn on the bedroom lights" to text, Speech-to-Intent directly extracts structured meaning:

intent: 'orderBeverage'
slots: {
  size: 'large',
  beverage: 'coffee',
}

This tutorial shows you how to build cross-platform voice command recognition in C using Rhino Speech-to-Intent, an on-device Speech-to-Intent engine. Rhino Speech-to-Intent processes voice commands locally and maps spoken phrases directly to actionable intents—no cloud round-trips, transcription overhead, or external audio transmission required. An open-source benchmark demonstrates that Rhino is six times more accurate than Google Dialogflow, Amazon Lex, and IBM Watson.

By the end of this guide, you'll have a working C application that recognizes custom voice commands entirely on-device with better privacy, reliability, and accuracy than cloud alternatives.

Important: This tutorial builds on How to Record Audio in C. Ensure your audio capture environment is ready before continuing.

Prerequisites

C99-compatible compiler
Windows: MinGW

Supported Platforms

Linux (x86_64)
macOS (x86_64, arm64)
Windows (x86_64, arm64)
Raspberry Pi (Zero, 3, 4, 5)

Project Setup

The tutorial will use the following directory structure:

project_root/
├── rhino_tutorial.c
├── pvrecorder/ # See "How to Record Audio in C" for setup instructions
│   ├── libpv_recorder.{so|dylib|dll}
│   └── include/
│       ├── pv_recorder.h
│       └── pv_circular_buffer.h
└── rhino/
    ├── coffee_maker.rhn
    ├── rhino_params.pv
    ├── libpv_rhino.{so|dylib|dll}
    └── include/
        ├── pv_rhino.h
        └── picovoice.h

For instructions on setting up audio capture (with pvrecorder), see: How to Record Audio in C

Step 1: Add Rhino library files

Create a folder named rhino/.
Download the Rhino header files from GitHub and place them in:

rhino/include/

Download a Rhino model file and place it in:

rhino/

Dynamic Loading Infrastructure

Rhino Speech-to-Intent ships as a shared library (.so, .dylib, .dll). Instead of linking at compile time, we'll load the library at runtime.

We'll build helpers to:

open a shared library
fetch function pointers
close it gracefully

These helpers remain identical whether you're using PvRecorder, Cheetah Streaming Speech-to-Text, Porcupine Wake Word, Rhino Speech-to-Intent, or other Picovoice engines.

Step 2: Platform-specific headers

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#else
#include <dlfcn.h>
#endif

#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#include "pv_rhino.h"
#include "pv_recorder.h"

Explaining the headers

On Windows systems, windows.h provides the LoadLibrary function to load a shared library and GetProcAddress to retrieve individual function pointers.
On Unix-based systems, dlopen and dlsym from the dlfcn.h header provide the same functionality.
Lastly, signal.h allows us to handle Ctrl-C later in this example.

Step 3. Define dynamic loading helper functions

3a. Open the shared library

static void *open_dl(const char *dl_path) {
#if defined(_WIN32) || defined(_WIN64)
    return LoadLibrary(dl_path);
#else
    return dlopen(dl_path, RTLD_NOW);
#endif
}

3b. Load function symbols

static void *load_symbol(void *handle, const char *symbol) {
#if defined(_WIN32) || defined(_WIN64)
    return GetProcAddress((HMODULE) handle, symbol);
#else
    return dlsym(handle, symbol);
#endif
}

3c. Close the library

static void close_dl(void *handle) {
#if defined(_WIN32) || defined(_WIN64)
    FreeLibrary((HMODULE) handle);
#else
    dlclose(handle);
#endif
}

3d. Print platform-correct errors

static void print_dl_error(const char *message) {
#if defined(_WIN32) || defined(_WIN64)
    fprintf(stderr, "%s with code '%lu'.\n", message, GetLastError());
#else
    fprintf(stderr, "%s with `%s`.\n", message, dlerror());
#endif
}

Implement Speech-to-Intent Detection

Now that loading infrastructure is in place, it's time to initialize Rhino Speech-to-Intent, start capturing audio, and pass frames into the engine.

Step 4: Load the Rhino library

Downloaded the correct library file for your OS and point library_path to the file.

const char *library_path = "./rhino/libpv_rhino.so"; // adjust per platform
void *rhino_library = open_dl(library_path);

Step 5. Initialize Rhino

Sign up for an account on Picovoice Console for free and obtain your AccessKey
Replace ${ACCESS_KEY} with your AccessKey
Create c custom context using the Picovoice Console and download the context file (.rhn)

You can also download one of the existing example context files instead of creating your own custom context.

Call pv_rhino_init to create a Rhino instance:

pv_status_t (*pv_rhino_init_func)(
    const char *,
    const char *,
    const char *,
    float,
    float,
    bool,
    pv_rhino_t **) = load_symbol(rhino_library, "pv_rhino_init");

static const char* access_key = "${ACCESS_KEY}"; // replace with your AccessKey
const char *model_path = "./rhino/rhino_params.pv"; // replace with your chosen model file
const char *context_path = "./rhino/coffee_maker.rhn"; // replace with your chosen context file
float sensitivity = 0.5f;
float endpoint_duration_sec = 1.f;
bool require_endpoint = true;

pv_rhino_t *rhino = NULL;
pv_status_t status = pv_rhino_init_func(
        access_key,
        model_path,
        context_path,
        sensitivity,
        endpoint_duration_sec,
        require_endpoint,
        &rhino);

Refer to pv_rhino_init for detailed explanation of parameters.

Step 6. See context info (optional)

You may want to see the context info so you know what commands you can say:

pv_status_t (*pv_rhino_context_info_func)(const pv_rhino_t *, const char **) =
    load_symbol(rhino_library, "pv_rhino_context_info");

const char *context_info = NULL;
status = pv_rhino_context_info_func(rhino, &context_info);
fprintf(stdout, "%s\n\n", context_info);

Step 7: Start listening for commands

Rhino requires int16 PCM frames of a specific length. Query this frame length with pv_rhino_frame_length and configure your recorder to produce frames of that size.
Continuously feed the recorded audio frames into pv_rhino_process.
pv_rhino_process returns a flag is_finalized when an inference is complete.
When is_finalized is true, use pv_rhino_is_understood to determine if the spoken command was recognized.
If recognized, call pv_rhino_get_intent to retrieve the intent and associated slots.
Release memory allocated for slots and values using pv_rhino_free_slots_and_values.
Call pv_rhino_reset before listening for the next command.

pv_status_t (*pv_rhino_process_func)(
    pv_rhino_t *,
    const int16_t *,
    bool *) = load_symbol(rhino_library, "pv_rhino_process");

pv_status_t (*pv_rhino_is_understood_func)(const pv_rhino_t *, bool *) =
    load_symbol(rhino_library, "pv_rhino_is_understood");

pv_status_t (*pv_rhino_get_intent_func)(const pv_rhino_t *, const char **, int32_t *, const char ***, const char ***) =
    load_symbol(rhino_library, "pv_rhino_get_intent");

pv_status_t (*pv_rhino_free_slots_and_values_func)(const pv_rhino_t *, const char **, const char **) =
    load_symbol(rhino_library, "pv_rhino_free_slots_and_values");

pv_status_t (*pv_rhino_reset_func)(pv_rhino_t *) = load_symbol(rhino_library, "pv_rhino_reset");

int32_t (*pv_rhino_frame_length_func)() = load_symbol(rhino_library, "pv_rhino_frame_length");

const int32_t frame_length = pv_rhino_frame_length_func();
int16_t *frame = malloc(frame_length * sizeof(int16_t));

while (!is_interrupted) {
    recorder_status = pv_recorder_read_func(recorder, frame);

    bool is_finalized = false;
    status = pv_rhino_process_func(rhino, frame, &is_finalized);

    if (is_finalized) {
        bool is_understood = false;
        status = pv_rhino_is_understood_func(rhino, &is_understood);

        const char *intent = NULL;
        int32_t num_slots = 0;
        const char **slots = NULL;
        const char **values = NULL;

        if (is_understood) {
            status = pv_rhino_get_intent_func( rhino, &intent, &num_slots, &slots, &values);

            printf("'intent':'%s'\n", intent);
            if (num_slots>0) {
                printf("'slots':{\n");
                for (int i = 0; i < num_slots; i++) {
                    printf("  '%s':'%s'\n", slots[i], values[i]);
                }
                printf("}\n");
            }
            
            status = pv_rhino_free_slots_and_values_func(rhino, slots, values);
        }

        status = pv_rhino_reset_func(rhino);
    }
}
free(frame);

Step 7: Cleanup resources

When done, delete Rhino to free memory and close the library:

void (*pv_rhino_delete_func)(pv_rhino_t *) =
    load_symbol(rhino_library, "pv_rhino_delete");

pv_rhino_delete_func(rhino);
close_dl(rhino_library);

Complete Example: On-device Speech-to-Intent Detection in C

Here is the complete rhino_tutorial.c you can copy, build, and run, complete with proper error handling and PvRecorder implementation:

Replace ${ACCESS_KEY} with your AccessKey from Picovoice Console
update model_path to point to the Rhino model file (.pv)
update library_path to point to the correct Rhino library for your OS
update context_path: to point to your chosen context file (.rhn)
update pv_recorder_library_path to point to the correct PvRecorder library for your OS

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#else
#include <dlfcn.h>
#endif

#include <getopt.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

#include "pv_rhino.h"
#include "pv_recorder.h"

static volatile bool is_interrupted = false;

void interrupt_handler(int _) {
    (void) _;
    is_interrupted = true;
}

static void *open_dl(const char *dl_path) {
#if defined(_WIN32) || defined(_WIN64)
    return LoadLibrary(dl_path);
#else
    return dlopen(dl_path, RTLD_NOW);
#endif
}

static void *load_symbol(void *handle, const char *symbol) {
#if defined(_WIN32) || defined(_WIN64)
    return GetProcAddress((HMODULE) handle, symbol);
#else
    return dlsym(handle, symbol);
#endif
}

static void close_dl(void *handle) {
#if defined(_WIN32) || defined(_WIN64)
    FreeLibrary((HMODULE) handle);
#else
    dlclose(handle);
#endif
}

static void print_dl_error(const char *message) {
#if defined(_WIN32) || defined(_WIN64)
    fprintf(stderr, "%s with code '%lu'.\n", message, GetLastError());
#else
    fprintf(stderr, "%s with `%s`.\n", message, dlerror());
#endif
}

int main(void) {
    signal(SIGINT, interrupt_handler);

    // PvRecorder dynamic loading
    const char *pv_recorder_library_path = "./pvrecorder/libpv_recorder.so";
    void *recorder_library = open_dl(pv_recorder_library_path);
    if (!recorder_library) {
        fprintf(stderr, "failed to load dynamic library at `%s`.\n", pv_recorder_library_path);
        exit(1);
    }

    const char *(*pv_recorder_status_to_string_func)(pv_recorder_status_t) =
        load_symbol(recorder_library, "pv_recorder_status_to_string");
    if (!pv_recorder_status_to_string_func) {
        print_dl_error("failed to load `pv_recorder_status_to_string`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_init_func)(const int32_t, const int32_t, const int32_t, pv_recorder_t **) =
        load_symbol(recorder_library, "pv_recorder_init");
    if (!pv_recorder_init_func) {
        print_dl_error("failed to load `pv_recorder_init`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_start_func)(pv_recorder_t *) =
        load_symbol(recorder_library, "pv_recorder_start");
    if (!pv_recorder_start_func) {
        print_dl_error("failed to load `pv_recorder_start`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_read_func)(pv_recorder_t *, int16_t *) =
        load_symbol(recorder_library, "pv_recorder_read");
    if (!pv_recorder_read_func) {
        print_dl_error("failed to load `pv_recorder_read`");
        exit(1);
    }

    pv_recorder_status_t (*pv_recorder_stop_func)(pv_recorder_t *) = load_symbol(recorder_library, "pv_recorder_stop");
    if (!pv_recorder_stop_func) {
        print_dl_error("failed to load `pv_recorder_stop`");
        exit(1);
    }

    void (*pv_recorder_delete_func)(pv_recorder_t *) = load_symbol(recorder_library, "pv_recorder_delete");
    if (!pv_recorder_delete_func) {
        print_dl_error("failed to load `pv_recorder_delete`");
        exit(1);
    }

    // Rhino dynamic loading
    const char *library_path = "./rhino/libpv_rhino.so"; // adjust per platform
    void *rhino_library = open_dl(library_path);
    if (!rhino_library) {
        fprintf(stderr, "failed to open library.\n");
        exit(1);
    }

    const char *(*pv_status_to_string_func)(pv_status_t) = load_symbol(rhino_library, "pv_status_to_string");
    if (!pv_status_to_string_func) {
        print_dl_error("failed to load `pv_status_to_string`");
        exit(1);
    }

    pv_status_t (*pv_rhino_init_func)(
        const char *,
        const char *,
        const char *,
        float,
        float,
        bool,
        pv_rhino_t **) = load_symbol(rhino_library, "pv_rhino_init");
    if (!pv_rhino_init_func) {
        print_dl_error("failed to load 'pv_rhino_init'");
        exit(1);
    }

    void (*pv_rhino_delete_func)(pv_rhino_t *) = load_symbol(rhino_library, "pv_rhino_delete");
    if (!pv_rhino_delete_func) {
        print_dl_error("failed to load 'pv_rhino_delete'");
        exit(1);
    }

    pv_status_t (*pv_rhino_process_func)(pv_rhino_t *, const int16_t *, bool *) =
        load_symbol(rhino_library, "pv_rhino_process");
    if (!pv_rhino_process_func) {
        print_dl_error("failed to load 'pv_rhino_process'");
        exit(1);
    }

    pv_status_t (*pv_rhino_is_understood_func)(const pv_rhino_t *, bool *) =
        load_symbol(rhino_library, "pv_rhino_is_understood");
    if (!pv_rhino_is_understood_func) {
        print_dl_error("failed to load 'pv_rhino_is_understood'");
        exit(1);
    }

    pv_status_t (*pv_rhino_get_intent_func)(
        const pv_rhino_t *,
        const char **,
        int32_t *,
        const char ***,
        const char ***) = load_symbol(rhino_library, "pv_rhino_get_intent");
    if (!pv_rhino_get_intent_func) {
        print_dl_error("failed to load 'pv_rhino_get_intent'");
        exit(1);
    }

    pv_status_t (*pv_rhino_free_slots_and_values_func)(const pv_rhino_t *, const char **, const char **) =
        load_symbol(rhino_library, "pv_rhino_free_slots_and_values");
    if (!pv_rhino_free_slots_and_values_func) {
        print_dl_error("failed to load 'pv_rhino_free_slots_and_values'");
        exit(1);
    }

    pv_status_t (*pv_rhino_reset_func)(pv_rhino_t *) =
        load_symbol(rhino_library, "pv_rhino_reset");
    if (!pv_rhino_reset_func) {
        print_dl_error("failed to load 'pv_rhino_reset'");
        exit(1);
    }

    pv_status_t (*pv_rhino_context_info_func)(const pv_rhino_t *, const char **) =
        load_symbol(rhino_library, "pv_rhino_context_info");
    if (!pv_rhino_context_info_func) {
        print_dl_error("failed to load 'pv_rhino_context_info'");
        exit(1);
    }

    int32_t(*pv_rhino_frame_length_func)() = load_symbol(rhino_library, "pv_rhino_frame_length");
    if (!pv_rhino_frame_length_func) {
        print_dl_error("failed to load 'pv_rhino_frame_length'n");
        exit(1);
    }

    static const char *access_key = "${ACCESS_KEY}"; // replace with your AccessKey
    const char *model_path = "./rhino/rhino_params.pv"; // replace with your chosen model file
    const char *context_path = "./rhino/coffee_maker_linux.rhn"; // replace with your chosen context file
    float sensitivity = 0.5f;
    float endpoint_duration_sec = 1.f;
    bool require_endpoint = true;

    pv_rhino_t *rhino = NULL;
    pv_status_t status = pv_rhino_init_func(
            access_key,
            model_path,
            context_path,
            sensitivity,
            endpoint_duration_sec,
            require_endpoint,
            &rhino);
    if (status != PV_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to init with `%s`", pv_status_to_string_func(status));
    }

    const int32_t frame_length = pv_rhino_frame_length_func();
    const int32_t device_index = -1; // -1 == default device
    const int32_t buffered_frame_count = 100;

    pv_recorder_t *recorder = NULL;
    pv_recorder_status_t recorder_status = pv_recorder_init_func(
            frame_length,
            device_index,
            buffered_frame_count,
            &recorder);
    if (recorder_status != PV_RECORDER_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to initialize device with %s.\n", pv_recorder_status_to_string_func(recorder_status));
        exit(1);
    }

    recorder_status = pv_recorder_start_func(recorder);
    if (recorder_status != PV_RECORDER_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to start device with %s.\n", pv_recorder_status_to_string_func(recorder_status));
        exit(1);
    }

    const char *context_info = NULL;
    status = pv_rhino_context_info_func(rhino, &context_info);
    if (status != PV_STATUS_SUCCESS) {
        fprintf(stderr, "'pv_rhino_context_info' failed with '%s'", pv_status_to_string_func(status));
        exit(1);
    }
    fprintf(stdout, "%s\n", context_info);

    int16_t *frame = malloc(frame_length * sizeof(int16_t));

    printf("Listening... Press Ctrl+C to stop.\n");
    while (!is_interrupted) {
        recorder_status = pv_recorder_read_func(recorder, frame);
        if (recorder_status != PV_RECORDER_STATUS_SUCCESS) {
            fprintf(stderr, "Failed to read with %s.\n", pv_recorder_status_to_string_func(recorder_status));
            exit(1);
        }

        bool is_finalized = false;
        status = pv_rhino_process_func(rhino, frame, &is_finalized);

        if (status != PV_STATUS_SUCCESS) {
            fprintf(stderr, "'pv_rhino_process' failed with '%s'", pv_status_to_string_func(status));
            exit(1);
        }

        if (is_finalized) {
            bool is_understood = false;
            status = pv_rhino_is_understood_func(rhino, &is_understood);
            if (status != PV_STATUS_SUCCESS) {
                fprintf(stderr, "'pv_rhino_is_understood' failed with '%s'", pv_status_to_string_func(status));
                exit(1);
            }

            const char *intent = NULL;
            int32_t num_slots = 0;
            const char **slots = NULL;
            const char **values = NULL;

            if (is_understood) {
                status = pv_rhino_get_intent_func(rhino, &intent, &num_slots, &slots, &values);
                if (status != PV_STATUS_SUCCESS) {
                    fprintf(stderr, "'pv_rhino_get_intent' failed with '%s'", pv_status_to_string_func(status));
                    exit(1);
                }

                printf("'intent':'%s'\n", intent);
                if (num_slots > 0) {
                    printf("'slots':{\n");
                    for (int i = 0; i < num_slots; i++) {
                        printf("  '%s':'%s'\n", slots[i], values[i]);
                    }
                    printf("}\n");
                }

                status = pv_rhino_free_slots_and_values_func(rhino, slots, values);
                if (status != PV_STATUS_SUCCESS) {
                    fprintf(
                            stderr,
                            "'pv_rhino_free_slots_and_values' failed with '%s'",
                            pv_status_to_string_func(status));
                    exit(1);
                }
            }

            status = pv_rhino_reset_func(rhino);
            if (status != PV_STATUS_SUCCESS) {
                fprintf(stderr, "'pv_rhino_reset' failed with '%s'", pv_status_to_string_func(status));
                exit(1);
            }
        }
    }
    free(frame);
    fprintf(stdout, "\n");

    recorder_status = pv_recorder_stop_func(recorder);
    if (recorder_status != PV_RECORDER_STATUS_SUCCESS) {
        fprintf(stderr, "Failed to stop device with %s.\n", pv_recorder_status_to_string_func(recorder_status));
        exit(1);
    }

    printf("Stopped.\n");
    pv_recorder_delete_func(recorder);
    pv_rhino_delete_func(rhino);
    close_dl(recorder_library);
    close_dl(rhino_library);
}

This is a simplified example but includes all the necessary components to get started. Check out the Rhino C demo on GitHub for a complete demo application.

Build & Run

Build and run the application:

Linux (gcc) and Raspberry Pi (gcc)

gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -I./rhino/include -o rhino_tutorial rhino_tutorial.c -ldl

./rhino_tutorial

macOS (clang)

clang -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -I./rhino/include -o rhino_tutorial rhino_tutorial.c

./rhino_tutorial

Windows (MinGW)

gcc -std=c99 -O2 -Wall -Wextra -I./pvrecorder/include -I./rhino/include -o rhino_tutorial.exe rhino_tutorial.c

./rhino_tutorial.exe

Troubleshooting Common Issues

1. Voice Commands Never Trigger Inference Detection

Ensure that audio is coming from the intended microphone. If you're using PvRecorder for audio capture, verify that it's functioning correctly before troubleshooting Rhino Speech-to-Intent.

Tips:

Confirm the microphone is not muted.
Make sure your application is reading audio frames at the exact size returned by pv_rhino_frame_length.
Check that your sample rate and PCM format match the engine's requirements (pv_sample_rate, single-channel).

2. Commands Are Frequently Missed

If Rhino Speech-to-Intent rarely detects commands, especially in noisy environments, your sensitivity settings may be too low.

Solution:

Increase the sensitivity value (range 0.0–1.0) during engine initialization. A higher sensitivity reduces missed detections but may slightly increase false positives.

3. High Rate of False Inferences

If Rhino Speech-to-Intent triggers in response to background speech or unrelated sounds, sensitivity may be too high.

Solution:

Lower the sensitivity during pv_rhino_init.
Ensure your microphone is not capturing unintended audio sources.
Avoid overlapping speech or loud background noise near the microphone.

4. Rhino Fails to Initialize

Initialization errors usually indicate mismatched files or platform issues. Common causes include using the wrong library, model, or context file for your system.

Solution:

Download the correct binaries for your OS and architecture from the Rhino repository.
Match the context file (.rhn) and model file (.pv) to the same language.
Ensure the context file and shared library (.so, .dylib, .dll) are compatible with your target platform.

Example (English "coffee_maker" context on Linux x86_64):

context file: coffee_maker_linux.rhn
model file: rhino_params.pv
library file: libpv_rhino.so

Start Building

Frequently Asked Questions

What is Rhino Speech-to-Intent and how is it different from STT?

Rhino is an on-device Speech-to-Intent engine. Unlike standard speech-to-text (STT), it directly converts spoken commands into structured intents without sending audio to the cloud. This makes it faster, privacy-friendly, and suitable for offline voice control applications.

How do I add custom commands or intents?

Use the Picovoice Console to create custom context files (.rhn) tailored to your application. You can define multiple intents and expressions, then download the context for use in your C project.

Does Rhino require an internet connection?

Rhino processes voice commands entirely on-device and does not send audio to the cloud. Internet is only required for licensing and usage tracking.

What programming languages can I use with Rhino?

Rhino provides C, C++, Python, JavaScript, Java bindings, and more. Refer to the official Rhino documentation for the full list.

How to Implement Cross-Platform Voice Control in C

Prerequisites

Supported Platforms

Project Setup

Step 1: Add Rhino library files

Dynamic Loading Infrastructure

Step 2: Platform-specific headers

Explaining the headers

Step 3. Define dynamic loading helper functions

3a. Open the shared library

3b. Load function symbols

3c. Close the library

3d. Print platform-correct errors

Implement Speech-to-Intent Detection

Step 4: Load the Rhino library

Step 5. Initialize Rhino

Step 6. See context info (optional)

Step 7: Start listening for commands

Step 7: Cleanup resources

Complete Example: On-device Speech-to-Intent Detection in C

Build & Run

Linux (gcc) and Raspberry Pi (gcc)

macOS (clang)

Windows (MinGW)

Troubleshooting Common Issues

1. Voice Commands Never Trigger Inference Detection

2. Commands Are Frequently Missed

3. High Rate of False Inferences

4. Rhino Fails to Initialize

Frequently Asked Questions

More from Picovoice