# SwiftSlate: rewriting any Android text field with a suffix trigger

> SwiftSlate is a Kotlin Android accessibility service that turns a typed suffix such as ?fix into an AI rewrite and swaps the result back into the same text field. It runs against Gemini, Groq or any OpenAI-compatible endpoint, including a local model on your own network, and it is published on F-Droid under the MIT licence.

**Musheer360/SwiftSlate** — Android accessibility service for AI-powered text transformation

- Repository: https://github.com/Musheer360/SwiftSlate
- Stars: 675 · Forks: 71
- Language: Kotlin
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/musheer360-swiftslate

## A suffix in the text field, not a keyboard shortcut

The interaction model is the whole idea. You type a message into any app, add a trigger at the end such as ?fix, and the text is rewritten in place while you watch. There is no copy, no paste, no trip to a separate assistant screen. The README describes the flow as type, trigger, done, with the AI response replacing your text directly in the same field.

While the request is in flight, an animated spinner is appended to the text so you can see that something is happening. The demo in the README shows an unpolished sentence with ?fix at the end turning into a corrected sentence, and a casual request with ?formal turning into a polite one. A third example uses ?translate:es to produce Spanish output.

Under the hood this is an Android Accessibility Service. That is the only mechanism that lets an app watch what you type in another app's text field and write back into it, and it is why the tool works across messaging, email, social media, notes and browsers without per-app integration work.

The cost of that mechanism is a permission the user has to grant deliberately. The README is upfront about the scope: works in most apps, with some apps that use custom input fields not supported. That caveat is the boundary of the whole product, and it is why the project also ships a text-selection route that does not need the accessibility permission at all.

## Two command types, and only one of them calls a model

The feature list names two command types, and the README splits the behaviour cleanly between them. AI commands send your text to the configured provider and wait for a rewritten result. Text replacer commands execute instantly, without a network round trip.

That split matters more than it sounds. A text replacer command is a local substitution, so it costs nothing, works offline and cannot fail because a provider is rate limiting you. The AI commands are the ones that need a key, a network and a provider that has not throttled you, and those are also the ones that carry the privacy weight.

There is a built-in command set, and the table of contents also lists a custom commands section, which means the trigger vocabulary is not fixed to whatever shipped in the build. If a command you want, such as a house-specific tone or a particular translation target, can be added, the tool becomes usable as a personal writing assistant rather than a fixed feature list.

The rest of the documented surface follows the same pattern of small, concrete pieces: API key management, a backup and restore feature for settings, a localization section for the interface, and a privacy and security section. The README also documents a way of trying a pull request without touching your existing install, which tells you the authors expect people to run modified builds alongside the released app.

## Point it at a cloud model or a local one, the wire format is the same

Provider support is the feature that decides how private your typing has to be. SwiftSlate ships with Google Gemini and Groq, and it also accepts any OpenAI-compatible endpoint. The README names local runtimes explicitly, including Ollama and LM Studio, and points out that these can run on your own network.

This is the real alternative to the cloud route, and the difference is concrete. A cloud provider gives you a hosted model with a key you obtain from that vendor, and your text leaves the device. A local endpoint, anything speaking the OpenAI-compatible API, keeps the text on your machine or your LAN, and the tool does not care which is which because the request shape is identical. You can even point the same build at a local server today and a hosted one tomorrow without changing how the commands work.

The trade-off is that SwiftSlate does not control the models behind those endpoints, so the quality of a rewrite depends on whatever is answering. The README describes the provider choice as its headline capability rather than promising a particular output, which is the honest framing for a thin client.

Multi-key rotation belongs in this section too. The feature list describes adding multiple API keys for automatic round-robin rotation, where a key that hits a rate limit causes the app to move to the next one. That is a practical answer to provider throttling on a free tier.

## The text-selection menu covers apps the service cannot reach

When the accessibility flow does not work in a given app, the project offers a second path with different permissions. You select any text, tap SwiftSlate in the Copy and Share popup that Android shows, and pick a command from there. The README states that this route requires no accessibility permission and works in any app offering the standard text-selection menu, including apps the accessibility flow cannot reach.

That is a sensible fallback design, since it inverts the trade-off. The accessibility route is fast and automatic, replacing text in place, but it needs a broad permission and depends on the app exposing its field in a way the service can see. The selection menu is manual and needs no broad permission, but it works almost everywhere Android draws a text selection handle.

The README also states that some apps with custom input fields may not be supported and points to a known limitations section for the detail, so the boundary is documented rather than hidden.

For a user, the practical implication is that SwiftSlate will feel incomplete in exactly the apps where you write most, unless you check early. The apps the README names as working include WhatsApp, Gmail, Twitter and X, Messages and Notes.

## Installing from F-Droid or a release APK, and what the build looks like

Distribution is straightforward. The README links the project to F-Droid under the package identifier com.musheer360.swiftslate, and to the GitHub releases page for a direct APK download, with a badge giving the download count and another giving an APK size of roughly 1.7 MB. There is also a Windows sibling project, SwiftSlate Desktop, described as the same concept working system-wide on Windows 10 and 11.

If you would rather build it, the repository has the pieces of a standard Android Gradle project: app/, build.gradle.kts, settings.gradle.kts, gradle.properties, a gradle/ directory and the wrapper scripts gradlew and gradlew.bat. On a Unix-like machine the wrapper is the entry point you invoke from the repository root:

```bash
gradlew
```

The README excerpt available here does not spell out the individual Gradle task names, so treat that invocation as the wrapper entry point rather than a documented task list. A fastlane/ directory sits at the root for store automation, and a build.yml GitHub Actions workflow is referenced by the build badge, so continuous integration builds exist for this project.

The first run is where the real setup happens. You need a provider: a Gemini or Groq key, or an OpenAI-compatible endpoint with its address and key, entered through the API key management screen. The on-screen text is composed in Jetpack Compose with Material 3, and the interface offers a pure black AMOLED theme along with a light one.

Nothing in the README describes a Play Store listing, so the F-Droid package and the GitHub release APK are the two documented routes to an install.

## MIT licensed, released often, and still an early API

SwiftSlate is MIT licensed, which matters for a tool that reads every keystroke you select. The repository also carries SECURITY.md, CONTRIBUTING.md and a CODE_OF_CONDUCT.md, so there is a stated place to report a problem and a stated process for contributing.

Release cadence is fast. Three tagged versions appear in quick succession: v1.0.80 on 2026-09-03, v1.0.81 on 2026-09-07 and v1.0.82 also on 2026-09-07. The last push to the repository was on 2026-10-16, so the branch has moved on from the published v1.0.82, and a build from the branch may contain changes that no release carries.

That pattern has a cost. A project that ships patch versions several times a week will change behaviour under you, and since the trigger commands and the provider plumbing are both configurable, a setting can shift meaning between builds. The CHANGELOG is the place to look before an upgrade, and the backup and restore feature exists for exactly that reason.

The privacy question deserves a plain answer rather than a reassuring one. An accessibility service that watches your text fields and forwards selected text to a model provider is holding a position that a normal keyboard does not. If that matters to you, the local endpoint route exists precisely so nothing leaves your network, and the privacy and security section of the README is the place to read what the app stores on the device.

## Conclusion

SwiftSlate suits Android users who type a lot into messaging, mail and notes apps and want a rewrite or translation without switching apps, and it suits people who refuse to send their text to a hosted model because any OpenAI-compatible endpoint works, including Ollama or LM Studio on your own machine. It does not suit you if your main apps use custom input fields that the accessibility flow cannot reach, since the README flags those as known limitations, and it does not suit anyone unwilling to grant an accessibility service permission, which is what makes the in-place replacement work. Check three things before installing: that the package you fetch is com.musheer360.swiftslate, whether from F-Droid or from a GitHub release APK, that you have a provider key or a reachable local endpoint configured in the API key management screen, and that your favourite apps accept the text-selection menu fallback. The most recent releases are v1.0.82, v1.0.81 and v1.0.80 from September 2026, and the last push was on 2026-10-16.

## FAQ

### How do I install SwiftSlate on my Android phone?

The README links a F-Droid package under the identifier com.musheer360.swiftslate and a GitHub releases page with a downloadable APK, whose size the badge puts at roughly 1.7 MB. The repository also contains the Gradle project files and the gradlew wrapper if you prefer to build it yourself.

### Can SwiftSlate work with a local LLM instead of a cloud provider?

Yes. Besides Gemini and Groq, it accepts any OpenAI-compatible endpoint, and the README names Ollama and LM Studio as local runtimes that can run on your network.

### What happens in apps that the accessibility service cannot handle?

The README describes a text-selection fallback: select text, tap SwiftSlate in the Copy and Share popup, and pick a command, which works without the accessibility permission. It also warns that some apps with custom input fields may not be supported.

### What is the difference between an AI command and a text replacer command?

AI commands send your text to the configured provider and return a rewritten result, while text replacer commands execute instantly without a model call.

### Is there a Windows version of SwiftSlate?

The README points to a separate project, SwiftSlate Desktop, described as the same concept working system-wide on Windows 10 and 11.

## Sources

- [Issues](https://github.com/Musheer360/SwiftSlate/issues)
- [License: MIT](https://github.com/Musheer360/SwiftSlate/blob/master/LICENSE)
- [Musheer360/SwiftSlate on GitHub](https://github.com/Musheer360/SwiftSlate)
- [README](https://github.com/Musheer360/SwiftSlate/blob/master/README.md)
- [Releases](https://github.com/Musheer360/SwiftSlate/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/musheer360-swiftslate