leopard: speech-to-text that never leaves the machine, except for the key check
On-device speech-to-text engine powered by deep learning
At a glance
- What is it?
- Picovoice's Apache-2.0 on-device transcription engine ships nine platform bindings and a demo for each language, with a default GGUF-style model file at lib/common/leopard_params.pv. The catch is licensing: recognition is fully offline, but the AccessKey still has to be validated against Picovoice servers.
- Who is it for?
- Leopard fits when transcription has to stay on the machine and you can accept one online step at startup. The engine runs locally and the audio does not move, but the AccessKey is validated against Picovoice license servers, so an air-gapped deployment needs that answered before you commit to it.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 3 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Picovoice/leopard485 ★ · +0
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| Picovoice/leopard | 485 | 485 |
0 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Recognition is fully offline, but the AccessKey is validated online
The privacy claim is specific and worth quoting exactly: all voice processing runs locally, and the voice recognition runs 100% offline. That is the reason to reach for this engine at all, and the architecture supports it, since the model runs as a native library rather than calling a service.
The licensing text then qualifies it. AccessKey is the authentication and authorization token for deploying Picovoice SDKs, including Leopard, and anyone using Picovoice needs a valid one. You must keep it secret. And you need internet connectivity to validate the AccessKey with Picovoice license servers, even though the recognition itself is offline.
So the offline property is about audio, not about the process. A deployment with no network has a problem, and the answer is not written down on this page. The same key also enforces account limits: usage limits and real-time usage are visible on the Console Profile, and continuing after a trial expires or adjusting limits means going through the Enterprise Sales Team or an existing Picovoice contact. Which means a running installation has a commercial dependency attached to it, not just a key.
v3.0 shipped in December 2025 and the branch has moved on since
Three tags exist. `v1.2` on 2023-03-28, `v2.0` on 2023-12-01, and `v3.0` on 2025-12-18. The spacing is uneven: about eight months from patch to major, then roughly two years to the next major.
The last push to the default branch, which is `master` rather than `main`, is dated 2026-10-01. That is close to ten months after the newest tag. Nothing is archived, and a repository with pushes that recent is not dormant, but the practical split is the same one that matters for any SDK: a tag gives you a 2025-12-18 snapshot, and the branch gives you ten months of unreleased work.
The default branch name is worth noting separately, because tooling that assumes `main` will not find it. The repository layout is also conventional for a native-plus-bindings project: `include/` for headers, `lib/` for the native libraries and the default model file, `resources/` for assets, `binding/` holding the per-language wrappers, and `demo/` holding every sample. A `Package.swift` at the root makes the iOS side consumable through Swift Package Manager, and a `.clang-format` governs the C sources.
Linux is listed as x86_64 only while macOS and Windows both list arm64
The cross-platform list is enumerated per architecture, and the asymmetry is easy to miss. Linux appears once, as x86_64. macOS appears twice, as x86_64 and arm64. Windows appears twice, as x86_64 and arm64.
So a Linux arm64 machine, which covers a large share of current Apple-adjacent and ARM server hardware, is not in the list. Nothing in the page says it is unsupported rather than merely unlisted, and the two readings lead to different decisions for a build engineer.
The rest of the matrix is broader. Android and iOS are both covered, as are Chrome, Safari, Firefox and Edge, which together account for the web bindings in vanilla JavaScript, React and a separate Express demo. Raspberry Pi is listed as versions 3, 4 and 5. Packaging follows the platform: Maven coordinates under `ai.picovoice` for the Android and Java artifacts, scoped npm packages, a NuGet package, a CocoaPod, a pub.dev package and a PyPI distribution.
The Raspberry Pi line is the other place where architecture is left implicit, since the three board generations span both 32-bit and 64-bit parts while the Linux entry above names only one architecture.
Eight languages ship, and everything else is a sales conversation
The language list has eight entries: English, French, German, Italian, Japanese, Korean, Portuguese and Spanish. That is the whole set included.
Anything beyond it is described as available for commercial customers on a case-by-case basis, with a link to a consulting page rather than a language list. So the coverage question has two answers depending on whether you buy, and the page does not enumerate what a commercial arrangement would add.
The Flutter demo makes the per-language setup concrete. You run a preparation script with a language code, `dart scripts/prepare_demo.dart ${LANGUAGE}`, where codes map to languages in the obvious way, and running the script with no code lists what is available. Running it without arguments as the default is the documented way to discover the set rather than reading it off a table.
The model file itself is not per-language either. The C demo points at a single default parameter file under `lib/common/`, which suggests one model artifact covering all eight, with the language selected at runtime rather than by swapping weights.
Every binding names its access key and audio argument differently
The demos are the clearest evidence that these are separate integrations rather than one wrapper with generated surfaces. The Python demo takes long flags:
pip3 install pvleoparddemoleopard_demo_file --access_key ${ACCESS_KEY} --audio_paths ${AUDIO_FILE_PATH}The Node.js demo takes a long flag for the key too, but a different name for the audio, and it is installed with yarn rather than pip:
yarn global add @picovoice/leopard-node-demoleopard-file-demo --access_key ${ACCESS_KEY} --input_audio_file_path ${AUDIO_FILE_PATH}The C demo goes the other way and uses short flags for everything, including two arguments the managed demos do not take at all. `-a` is the access key, `-l` the path to the library under `lib`, and `-m` the model file, defaulting to the file in `lib/common/leopard_params.pv` or one you supply:
cmake -S demo/c/ -B demo/c/build && cmake --build demo/c/build./demo/c/build/leopard_demo -a ${ACCESS_KEY} -l ${LIBRARY_PATH} -m ${MODEL_FILE_PATH} ${AUDIO_FILE_PATH}Porting a script between languages means renaming arguments, not just translating syntax.
Mobile demos put the AccessKey in a source file you edit by hand
The mobile samples take a different approach entirely, and it is worth noticing because it is the opposite of what the managed demos do. The iOS demo tells you to run `pod install`, then replace `let accessKey = "${YOUR_ACCESS_KEY_HERE}"` in `ViewModel.swift` with your key, then open the generated `LeopardDemo.xcworkspace` in Xcode. The Android demo tells you to open the project in Android Studio and replace the same placeholder string in `MainActivity.java`.
The Flutter demo does the same in `main.dart`, after the language preparation step. So in three of the demos the key is written into a file that would be committed by a careless workflow. The page states plainly that the AccessKey must be kept secret, and the mobile setup is where that instruction is easiest to violate.
The other difference is build tooling. Desktop and web demos are compiled or installed from a package registry, while the mobile ones require CocoaPods and Xcode, or Android Studio, before anything runs. Nothing about the engine differs; everything about the entry path does.
Fourteen demo directories, and the page walks through ten
The demo folder holds fourteen entries: Android, C, dotnet, expressjs, flutter, ios, java, nodejs, three separate Python directories, react-native, react and web. The table of contents and the sections that render cover ten of them.
The gap is worth mapping. There is an `expressjs` directory with no corresponding section, even though the web section exists and covers vanilla JavaScript with HTML and React. Express is a server-side framework and would not be a browser binding, so it may belong to the same platform grouping without its own heading, but nothing states that.
The three Python directories are the other case. `demo/python/` is the one the visible section covers, with a single demo package and a single-file command. Alongside it sit `demo/python-subtitle/` and `demo/python-youtube/`, which read as two additional applications built on the same binding, one for producing subtitles and one for a YouTube-oriented workflow. Neither appears in the rendered documentation.
For a project whose selling point is that every platform has a runnable sample, four unlisted demo directories mean the page understates what is actually in the repository.
Six ecosystems, six naming conventions
The distribution identifiers do not share a scheme, which is a small tax when you add a second language to a project or write a Dockerfile that pulls from more than one registry.
Maven uses `ai.picovoice` as a group prefix with `leopard-android` and `leopard-java` artifacts. npm scopes under `@picovoice` with a hyphenated suffix, covering `leopard-node`, `leopard-react`, `leopard-react-native` and `leopard-web`. NuGet uses a bare `Leopard`, and CocoaPods uses `Leopard-iOS` with a hyphen and a platform suffix. Python's PyPI name is `pvleopard`, which carries neither the vendor nor the product name in the obvious place. Flutter's pub.dev package is `leopard_flutter`, unscoped and snake-cased.
Three conventions are visible in that list: dotted group prefix for Java, scoped or hyphenated vendor prefix for npm, and bare or snake-cased product name everywhere else. None of it is wrong, but a build that resolves across Maven, npm and PyPI has to hardcode three different naming rules.
The final section of the page, covering the React Native demo, stops inside a directory path partway through, so whatever it says about that setup is not written down here.
Editorial conclusion
Leopard fits when transcription has to stay on the machine and you can accept one online step at startup. The engine runs locally and the audio does not move, but the AccessKey is validated against Picovoice license servers, so an air-gapped deployment needs that answered before you commit to it. Two smaller checks. The eight shipped languages are the only ones included, and anything else is a case-by-case commercial arrangement. And the newest tag is v3.0 from 2025-12-18 while the master branch has moved on since, so decide whether you want the release or the branch before pinning a version. Last, keep the key out of the source files where the mobile demos put it.
Frequently asked questions
Does leopard send audio anywhere?
No. All voice processing runs locally, and recognition is described as running 100% offline. You do need internet connectivity to validate your AccessKey with Picovoice license servers, and to stay within your account usage limits.
What is a Picovoice AccessKey and where do I get one?
It is the authentication and authorization token for deploying Picovoice SDKs, and anyone using Picovoice needs a valid one. Keep it secret. Your usage limits and real-time usage appear on the Picovoice Console Profile.
Which languages does leopard support?
English, French, German, Italian, Japanese, Korean, Portuguese and Spanish. Additional languages are available for commercial customers on a case-by-case basis rather than from a published list.
Which platforms does leopard run on?
Linux on x86_64, macOS and Windows on both x86_64 and arm64, Android and iOS, Chrome, Safari, Firefox and Edge, and Raspberry Pi 3, 4 and 5. A Linux arm64 build is not in the list.
Why does the C leopard demo need a library and model path?
Its arguments are `-a` for the access key, `-l` for the library under `lib`, and `-m` for the model file, which defaults to `./lib/common/leopard_params.pv` or your own. The Python and Node.js demos take neither path.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/picovoice-leopard)Star history chart for your README
[](https://hysenlabs.com/projects/picovoice-leopard)Was this useful?