Ramblr (FOSS) – Tap-to-dictate voice input for Android

Speak it. Tap once, ramble, tap again — clean text lands wherever your cursor is.

Ramblr is an Android dictation app that puts a small floating mic on your screen. Tap it in any app, talk however you actually talk, tap again — and polished text appears in the field you were already typing in. No keyboard swap, no separate transcript window, no copy-paste.

Ramblr isn't just the floating button. Pick whichever fits the moment — most can be active at once.

Settings → Invocation is where you choose between them.

A draggable mic ring floats above other apps. Tap to record, tap to stop; the cleaned text is inserted into whatever field had focus. Long-press does something useful depending on state — cancel while transcribing, undo a just-inserted result, or open the style quick-menu when idle.

It auto-hides ("peeks") to the screen edge when idle so it isn't in your way, and both the delay and the look — size, border, fill, glyph color, or a fully custom icon image — are configurable.

A voice-only input method: mic, live status, a cleanup-style picker, three quick edit keys, keyboard switcher, settings shortcut. It inserts text through Android's standard InputConnection, so it works with the accessibility service turned off entirely.

It is deliberately not a full keyboard — no letter, number, or symbol rows (the edit keys are only for fixing dictation), no swipe typing, autocorrect, suggestions, clipboard, or emoji UI. Switch back to your usual keyboard to type. The panel follows your system light/dark theme.

Password, PIN, and web-password fields disable the mic completely. Editors requesting Android's "no personalized learning" flag still work, but those sessions are excluded from history, quality logging, and vocabulary suggestions.

The floating icon follows the same rule: it won't start recording while a password field has focus (it shows "Ramblr doesn't dictate into password fields"), and a dictation whose field turns out to be a password field is discarded rather than inserted, copied, or saved to history.

Instead of an on-screen ring, trigger dictation from Android's own accessibility button/gesture, or by holding both volume keys.

This mode uses a second service component, and there's a real trade-off worth knowing: turning off the last bound Ramblr shortcut in system Settings also disables the service itself (an Android INVISIBLE_TOGGLE behavior, not a Ramblr bug). Ramblr detects that state and shows a recovery banner. Volume-key hold is restricted to this mode on purpose — binding it in floating-icon mode would make your volume keys toggle the service instead of dictation.

Power-user option: granting WRITE_SECURE_SETTINGS via ADB lets Ramblr flip these bindings in-app instantly and sidestep that trap. It's entirely optional — without it you get a one-tap deep link into system Settings.

adb shell pm grant com.trevornk.ramblr android.permission.WRITE_SECURE_SETTINGS

4. Quick Settings tile

Swipe down and tap the Ramblr tile to start or stop dictation. On Android 13+ the app asks the system to add the tile for you; below that you'll get instructions to add it by hand. Android never tells an app whether its tile was actually placed, so that settings row is a "how to add it" helper, not a live status readout.

Select text in any app, tap Ramblr in Android's selection menu, pick a style, and the cleaned text replaces it (or lands on your clipboard if the field is read-only). Great for tightening a message you already typed.

This path touches the accessibility service not at all — it doesn't need to be enabled, and Ramblr never reads your screen to make it work.

Install — grab the APK from Releases and sideload it, or build from source.

Open Ramblr and pick how you want to dictate — enable the Accessibility service for the floating icon, or enable Ramblr Voice in Android's keyboard settings if you'd rather not.

Grant microphone permission. Every mode needs it.

Choose a dictation mode (Settings → Cloud):

Local — on-device transcription + on-device cleanup, fully offline

Cloud — cloud transcription + cloud cleanup

Fastest — on-device transcription (near-instant) + cloud cleanup (best text quality)

Download a model (Settings → Transcription) if you chose Local or Fastest, or add an API key (Settings → Cloud) if you chose Cloud or Fastest.

You tap the ring (or tile, or keyboard mic) and talk.

Audio is transcribed — on-device or in the cloud, your choice.

Optional cleanup fixes grammar, punctuation, filler words, and self-corrections.

The text is inserted into the focused field.

If insertion fails, it's copied to your clipboard and the feedback bubble stays up longer and stays tappable, so a failed insert is hard to miss.

Offline or cloud — your call

Transcription and cleanup are chosen independently, so "local transcription + cloud cleanup" is a perfectly normal setup.

Pair local transcription with local cleanup and nothing ever leaves the device. In every cloud mode, requests go straight from your phone to the provider with your own key — there is no relay server in the middle. I don't run a backend for this app.

Cleanup isn't one provider. Settings → Cloud builds an ordered chain — "try Gemini Flash, fall back to OpenAI, fall back to Anthropic, fall back to on-device" — and Ramblr walks it on any timeout, non-2xx, or network error. If every step fails, you get the raw transcript; your words are never silently dropped.

Design rationale: docs/adr/0001-cleanup-waterfall.md.

Downloaded on demand, checksum-verified, stored in app-private storage. Nothing is bundled into the APK.

On-device cleanup uses Mumble Cleanup 2-Stage (352 MB, Apache-2.0, a Qwen2.5-0.5B fine-tune trained specifically for transcript cleanup) by default; LFM2.5 350M (219 MB) is available as an alternative. A separate 57 MB streaming model powers Live Preview.

Beyond the six built-ins you can write custom styles, fork a built-in (editing one creates a copy rather than mutating the preset), choose which styles appear in the long-press quick menu, and set a per-app style — Email in Gmail, Notes & lists in your scratchpad. Ramblr remembers the style you pick in a given app and reuses it there next time (on by default).

Natural, Formal, and Casual are meant to keep your wording, so for cloud cleanup Ramblr checks the model's answer against what you said (numbers, names, length, no invented phrases, no chatty replies). If the answer fails the check, it inserts your raw transcript and tells you cleanup was skipped instead of typing words you didn't say.

Personal vocabulary teaches cleanup your project names and jargon. On the local cleanup path a deterministic post-pass fixes near-misses ("clawed code" → "Claude Code") — done after the model rather than by prompting it, because interpolating a long term list into a small local model made it echo the list back as output. Cloud cleanup interpolates the list into the prompt, where that works fine.

Smart vocabulary suggestions (on by default) notice words cleanup keeps correcting, or unusual names that recur, and offer them as one-tap additions. A term must appear in at least 3 dictations across 2 different days before it's suggested. Only the candidate word is ever stored — never transcript text — and turning the feature off erases every accumulated candidate.

There are two different "live" behaviors in Ramblr, and they are not the same thing:

Local streaming preview (Settings → Live Preview, off by default) shows partial text updating as you talk, using a small on-device streaming model. It works with the floating icon / accessibility mode as well as the keyboard. The final inserted text still comes from the regular transcription pipeline — streaming only changes what you see while speaking. It's always local, never cloud. If "Preview before inject" is on, partials render in the floating bubble instead of your real field.

Gemini Cloud Live (Settings → Cloud, off by default) is an experimental cloud streaming path. It costs roughly 1.8× the batch price, hasn't completed real-device validation, and is currently wired into the Ramblr Voice keyboard only — the floating-icon route does not render cloud interim text and falls back to normal batch behavior. Tracked in #233 and #245.

Behavior — auto-stop after silence (off by default, on-device VAD, 2.0 s threshold); auto-hide/peek delay; single-tap restore-and-record; the "tap to use raw text" undo bubble (on by default); preview-before-inject; per-app style memory; compressed audio uploads for cloud transcription (off by default — quality impact hasn't been measured yet, so it's opt-in).

Overlay appearance — ring size (44/56/76 dp or custom), border, idle fill, glyph color with an opacity slider, or a fully custom icon image. Recording and transcribing colors stay fixed because they convey real state.

Data & logs — your last 50 dictations are kept locally so a failed insertion is recoverable (on by default, tap to copy, long-press to delete). A benchmark log records timings and model IDs but never transcript text. A separate quality log does store your actual words for A/B review, so it's off by default and excluded from backups. Manual backup/restore exports history, benchmark log, and settings as a zip — API keys are deliberately excluded because their encryption is bound to the device keystore and couldn't be decrypted elsewhere anyway.

Numbers spoken aloud get normalized on the local cleanup path ("four thirty" → "4:30"), and it stays conservative on purpose — ambiguous quantifiers like "half" or "a dozen" are left alone.

Ramblr works best in apps using standard Android text fields. Some apps use custom or terminal-style surfaces where direct insertion doesn't work; there, Ramblr falls back to the clipboard and keeps the bubble up and tappable.

There's no table of tested apps here, because building one honestly means exercising each app on a real device — tracked in #5. Don't read a missing app as either supported or unsupported.

Termux's terminal area isn't a standard text field. Swipe the extra-keys row (ESC, CTRL, arrows) left or right to reach Termux's native input box, dictate there, and Termux forwards it to the terminal normally.

For exactly one thing: inserting dictated text into the focused field across apps. Ramblr's onAccessibilityEvent handler is empty — it does not read your screen, and it does not run background automation. It acts only when you tap its mic. The keyboard and select-text paths don't use the service at all.

The one exception is a setting you have to turn on yourself. If you choose Behavior → Show the icon → Only while the keyboard is open (or While a text field is selected), Ramblr also listens for window and focus changes to know when a text field or keyboard is showing. It never reads what's on screen. With the default (Always) it listens for nothing extra, and switching back to Always stops it right away.

git clone --recursive https://github.com/trevornk/ramblr.git && cd ramblr make build

--recursive matters — llama.cpp is a submodule the on-device cleanup build needs. If you already cloned without it: git submodule update --init --recursive. The sherpa-onnx native libs download automatically.

make build # debug APK -> app/build/outputs/apk/github/debug/ make test # JVM unit tests, no device needed make adb-install # build + install over ADB make clean

Distribution flavors

github (default) — the sideload build on Releases. The only flavor with self-update.

storefront — for Google Play / F-Droid. Self-update code is physically absent from the compiled classes, not runtime-disabled: make build FLAVOR=storefront.

That split exists because Play's policy forbids an app updating itself outside Play's own mechanism, and F-Droid assumes the client controls updates. Keeping self-update in its own source set means it can't violate that policy in a storefront build at all.

Checks Releases every 6 h. Notifies by default; can optionally auto-ins