Transcribro: an on-device Whisper keyboard for Android

An input method that is also a system speech service

Transcribro is a private and on-device speech recognition keyboard and service for Android. The name of the project is a play on transcribe, and the two words in the description are the two things it is.

As a keyboard, it is a voice input method: it lets you type with speech, so you switch to it in any text field, speak, and the recognised text is inserted. As a service, it registers with Android as a speech to text provider, and it says other apps can use it either explicitly or when it is set as the user-selected speech to text app, which some apps will pick up automatically.

That second role is the more interesting one and the one that makes the project more than a keyboard. Android has a system setting for the default speech to text engine, and an app that registers there can be used by any application that shells out to the system recogniser rather than shipping its own. For someone who wants their dictation handled locally, setting Transcribro as the system engine means the benefit extends beyond the keyboard itself.

The stack is two specific components. It uses whisper.cpp to run the OpenAI Whisper family of models, and Silero VAD for voice activity detection. The VAD piece matters more than it first appears: it is what decides when you have started and stopped talking, so a recorder that is always listening can cut the audio at the right moments without clipping the first syllable or dragging in the next utterance.

The project is written in Kotlin, the topic list shows a Jetpack Compose interface built around Material 3 and Material You, and the licence is ISC.

Everything runs on the phone, which is the point

The privacy claim is architectural rather than a policy statement, and the repository layout backs it up.

The top level of the project includes a `whisper.cpp` directory and a `.gitmodules` file, so the Whisper inference engine is vendored as a submodule rather than being a remote service. The app code is split between `app/` and `lib/`, with the `lib/` module holding the parts of the integration that are not Android UI, which is the usual shape for a Kotlin project that wraps a native library.

The three licence files at the root tell you the provenance of the components. There is `LICENSE.openai-whisper.txt` for the model weights, `LICENSE.silero-vad.txt` for the voice activity detector, and `LICENSE.whisper.cpp.txt` for the inference engine, alongside the project's own `LICENSE.txt`. So the models, the detector and the engine are each covered by their own terms, and the project has been careful to keep those separate rather than folding everything into one file.

The build is a standard Gradle Kotlin DSL project, with `build.gradle.kts`, `settings.gradle.kts`, `gradle.properties`, a `gradlew` wrapper and `gradlew.bat`. The `.idea/` directory is present, and the app module holds the Compose UI.

The practical consequence of on-device inference is that the model has to live on the device, so the first run involves a download and the app carries a storage and memory cost that a cloud recogniser does not. The repository does not document model sizes or which Whisper models the app offers, so that is something to check in the app itself rather than assume from the README.

Verify the APK against a published certificate hash

The download section is unusually careful about authenticity, and for a keyboard that can read everything you type into it, that is the right thing to be careful about.

Transcribro is distributed through the Accrescent app store and through GitHub releases, and the README says Accrescent is the recommended way to get it because it is more secure than GitHub releases. Accrescent is presented as the app store alternative, with a badge linking to the listing for the dev.soupslurpr.transcribro package.

For the direct APK route, the project publishes the package name and the SHA-256 hash of the signing certificate, and points at `apksigner` from the Android command line tools to check it. The verification command is `apksigner verify --print-certs Transcribro-X.Y.Z.apk`, run against the downloaded file.

The published certificate hash is:

7D:BC:FB:FA:A1:35:B4:4E:6E:93:91:02:25:DC:B1:4E:05:82:91:DA:8C:2D:36:22:73:49:49:B7:1A:B3:BE:64

alongside the package name `dev.soupslurpr.transcribro`.

There is a second tool in the picture. The README also links to AppVerifier, a separate project by the same author, and says that if you install from Accrescent you should verify Accrescent itself using that store's own verification instructions.

The last detail is the one that shows how the project thinks about trust. The certificate hash is also published on a Bluesky post, and the README explicitly frames that as a way for distrusting the website to distribute the same value, and encourages people to check it against each other for assurance. Publishing a hash on your own site proves only that your site was not tampered with, so giving people a second channel to compare against is the part that actually adds trust. It is a small practice, but it is the correct one.

English only, with other languages tracked as an open issue

The language support story is the clearest limitation in the project. The README states that Transcribro currently only supports English, and that supporting other languages is planned and tracked in issue 18 in the repository.

Worth being precise about what the Whisper models themselves offer versus what this app exposes. Whisper is a multilingual model family, so the underlying engine is not the constraint. The constraint is elsewhere: on-device inference needs the model weights to be downloaded and stored, and a user who wants one language should not have to carry a multi-gigabyte multilingual model on a phone. Curating and packaging a separate build per language is a distribution and size decision, not a research one.

That also explains why the app is a keyboard rather than a general voice assistant. A keyboard is invoked deliberately, for a short burst of dictation, which is a workload a phone can handle locally. Continuous background listening through a hot word is a different problem, and nothing in the project suggests it is attempted.

The release history shows a versioning inconsistency worth noting if you are tracking the app. The listed releases are 7 from 2025-08-07, v0.3.1 from 2025-01-16 and v0.3.0 from 2024-06-05. So the tags move from semver style to a bare integer between 0.3.1 and 7, and the 7 tag is the most recent. There is no GitHub release cadence described in the repository beyond that.

Against a cloud recognizer and against a plain voice keyboard

The two alternatives to this app are the phone's built-in speech service and a third-party keyboard with cloud transcription, and the difference in approach is where the audio goes.

The built-in Android recogniser is free, already installed and generally better at the language it supports, because it is backed by a large server-side model. What it costs you is that your audio is uploaded to a service you do not control, on a path the vendor can change. For someone dictating a password into a password manager, or a medical detail into a chat, that is the thing Transcribro is for.

A cloud-backed voice keyboard is a middle option with the same property, plus a vendor account and an app with more permissions than a keyboard strictly needs.

The cost side of the trade is concrete. On-device Whisper inference is slower than a server round trip, it consumes battery and thermal headroom, and it needs storage for the model. On a mid-range phone, a long paragraph will not land as fast as a cloud recogniser, and the model download is a one-off cost that has to happen before the first use.

There is a third option for people who only need this occasionally: run Whisper locally on a desktop, for example with whisper.cpp itself, and use a text field to paste the result. That is more friction per use, but it keeps the audio off the phone entirely and leaves no keyboard installed.

What Transcribro offers against all three is the combination, which is rare: a system speech service that works for any app, running entirely on the device, with the authenticity of the install made checkable rather than assumed.

What the README leaves open about models, settings and build

Several things a person evaluating this app would look for are simply not in the repository documentation, and it is worth knowing where the gaps are.

The model story is the largest gap. The README says the OpenAI Whisper family of models is used, but it does not list which models the app offers, their sizes, or how a user chooses between them. Since the app is on the Accrescent store rather than a package repository, the answer is in the app itself.

Build instructions are also absent. The CONTRIBUTING.md file is linked for anyone who wants to contribute, and the project is a Gradle project with a `whisper.cpp` submodule, so a contributor would need to initialise that submodule and satisfy the native toolchain requirements for whisper.cpp before anything would compile. None of that is spelled out in the README.

The repository does not describe any configuration surface either, beyond the Compose and Material 3 topics that suggest a themed interface. Whether there is a settings screen for language, model, or whether dictation inserts into the field with punctuation and casing applied is not documented.

The community side is clear enough. There is a Matrix space at matrix.to with General, Announcements and Testing rooms, and the contribution guide is a separate file.

The last push was on 2026-09-29, and the repository is not archived, so work on the project continues even though the release tags have not moved since the 7 tag in August 2025.

Editorial conclusion

Adopt Transcribro if you want to dictate text into any Android app without sending audio to a cloud service, and if English only is acceptable, since other languages are still tracked as an open issue. Do not adopt it if you need multilingual dictation or a stable release cadence, because the newest listed release is a plain 7 from 2025-08-07 while the earlier tags are semver style, and check the certificate hash against the value published in the README before you install the APK, since the project ships a verifier for exactly that reason.

Frequently asked questions

Official sources

1. Issues
2. License: ISC
3. README
4. Releases
5. soupslurpr/Transcribro on GitHub