Picovoice/rhino

What is Rhino?

Rhino is a speech‑to‑intent engine from Picovoice. It listens to a microphone (or an audio file), runs a tiny neural‑network on‑device, and directly returns a structured intent – the what the user wants to do – together with any extracted variables (called slots). For example, saying:

“Can I have a small double‑shot espresso?”

produces:

{
  "isUnderstood": true,
  "intent": "orderBeverage",
  "slots": {
    "beverage": "espresso",
    "size": "small",
    "numberOfShots": "2"
  }
}

Why it matters

On‑device, low‑latency – no cloud round‑trip, so it works offline and respects privacy.
Tiny footprint – designed for micro‑controllers (Cortex‑M), Raspberry Pi, phones, browsers, and desktop OSes.
Customizable – developers create their own contexts (sets of commands) with the Picovoice Console.
Cross‑platform SDKs – ready‑to‑use libraries for Python, .NET, Java, Flutter, React Native, Android, iOS, Web (JS), Node.js, and plain C.

How does it work?

Define a context – a YAML file that maps expressions (what a user might say) to an intent and optionally marks parts of the expression as slots (variables). Example:
```
turnLightOff:
  - Turn off the lights in the $location:lightLocation.
```
Train the model – Picovoice’s cloud service compiles the context into a binary (*.rhn) that embeds a small neural network tuned for that domain.
Run inference – The SDK loads the binary and, frame‑by‑frame, processes 16‑bit PCM audio. When the utterance is complete it returns an Inference object containing is_understood, intent, and a dictionary of slots.

Getting started (quick‑start example in Python)

# install the SDK
pip3 install pvrhino

import pvrhino

access_key = "YOUR_ACCESS_KEY"
context_path = "/path/to/your/context.rhn"

rhino = pvrhino.create(access_key=access_key, context_path=context_path)

while True:
    audio_frame = get_next_audio_frame()          # 16‑bit PCM, length = rhino.frame_length
    if rhino.process(audio_frame):                # returns True when utterance is complete
        inf = rhino.get_inference()
        if inf.is_understood:
            print("Intent:", inf.intent)
            print("Slots:", inf.slots)
        else:
            print("Did not understand")
        rhino.delete()                            # free native resources
        break

The same pattern exists for the other languages; each SDK exposes sample_rate, frame_length, process(), and get_inference().

Where can I try it?

Web demo – an interactive barista demo at https://picovoice.ai/demos/barista/
Desktop / embedded demos – pre‑built C, Python, .NET, Java, Flutter, React‑Native, Android, iOS, and Node.js examples are in the demo/ folders. They show both microphone‑live and file‑based inference.
Benchmarks – a public comparison against cloud services is linked in the README (see speech-to-intent-benchmark).

Who is it for?

IoT / embedded devices where you need always‑listening voice control without sending audio to the cloud (smart lights, coffee makers, thermostats, etc.).
Mobile apps that want offline voice commands.
Web applications that need privacy‑preserving voice interaction.
Prototypers who want to define a small, fixed set of commands quickly via the Picovoice Console.

Limitations

It is optimized for specific, limited vocabularies (a context). It is not a general‑purpose speech recognizer.
An access key (free for trial, commercial licensing for production) is required to load the engine.
Custom language support beyond the listed 9 languages is only available to commercial customers.

Quick reference links

GitHub releases – https://github.com/Picovoice/rhino/releases
Picovoice Console (create contexts) – https://console.picovoice.ai/
SDK documentation – see the language‑specific sections under SDKs in the README.
Package managers – Maven, npm, NuGet, CocoaPods, Pub, PyPI all host the respective bindings.

TL;DR

Rhino lets you embed a tiny, offline neural‑network that turns spoken commands into structured intents. It works on everything from micro‑controllers to browsers, and you can define your own command set via a simple YAML‑based console. If you need reliable, low‑latency voice control for a fixed domain, Rhino is the go‑to solution.