LeanType: a HeliBoard keyboard with AI proofreading bolted into the input method
LeanType is an Open-source keyboard, fork of HeliBoard with additional features and customisation
At a glance
- What is it?
- LeanType is a GPL-3.0 Kotlin fork of HeliBoard, OpenBoard and AOSP LatinIME that adds cloud and on-device language models, in-keyboard OCR, translation and voice typing to an otherwise conventional Android keyboard. The judgement is that the interesting part is the flavour split between a cloud-capable build and an offline build, and that the AI features are plugin-gated rather than baked into the core.
- Who is it for?
- LeanType fits an Android user who already likes HeliBoard and wants proofreading, translation and text extraction without leaving the keyboard, and who is either willing to use a cloud model provider or prepared to run a local GGUF model on the device.
- Can I use it commercially?
- Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Kotlin, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 23, 2026, and from our analysis. They are not legal advice.
Editorial analysis
Two flavours, and the difference is a permission
LeanType is an open-source Android keyboard, forked from HeliBoard, which is itself derived from OpenBoard and AOSP LatinIME. The positioning in one line is a private, smart and deeply customizable open-source keyboard.
The most consequential decision in the project is the flavour split. LeanType ships as two builds, `-standard-release.apk` and `-offline-release.apk`, with separate package identifiers, `com.leanbitlab.leantype` and `com.leanbitlab.leantype.offline`.
The standard flavour is the recommended one, aimed at F-Droid and direct download users. It has cloud AI, offline and AI translation, voice typing via a plugin, handwriting via a plugin, and OCR text extraction from camera and screenshots, also via plugin. It has a release update checker that reads GitHub Releases, and its internet permission is optional, tied to cloud AI and updates.
The offline flavour is for privacy purists and air-gapped devices. It has no cloud AI but it does have offline AI, local GGUF models through llama.cpp, on Android 8.0 and later, installed via plugin. It has no release update checker, and the internet permission is absent and blocked at the OS level. Its minimum Android version is 5.0, and its approximate APK size is 9.8 MB against 10.8 MB for the standard build.
Both editions operate with zero sensitive permissions, specifically no `READ_CONTACTS`, no `SYSTEM_ALERT_WINDOW` and no `REQUEST_INSTALL_PACKAGES`. That is the fork's clearest statement of intent.
There is also a migration note. As announced in v4.2.5, `standardfull` was completely merged into `standard` in v4.2.6, and users of the old edition can update directly with data and settings preserved.
The AI layer is deliberately indirect
The AI features are the fork's headline, and the design is worth reading closely because it is not simply a chat box in a keyboard.
The cloud side supports Google Gemini, Groq with Llama 3.3, Mixtral and DeepSeek, OpenAI, or any self-hosted local LLM server, with Ollama, LM Studio, LocalAI, vLLM and custom OpenAI-compatible endpoints named. The list of capabilities is integrated proofreading, grammar correction and text rewriting.
There is dynamic model fetching, which automatically fetches and populates the latest available model IDs directly from your cloud or self-hosted provider, so you are not hardcoding a model name that goes out of date.
The offline side is the more interesting engineering. The offline flavour runs compact, quantized GGUF language models directly on the device through an embedded llama.cpp, with the project describing it as 100% private and zero network access.
What makes this a keyboard design rather than a feature list is the customisation layer. There are custom AI keys and capsules, where you assign custom prompts, personas such as `#editor` and `#proofread`, and themed tag capsules to 10 customizable toolbar keys. The idea is that the AI call is a function of the surrounding text and the persona you picked, invoked from a key you already have under your thumb, rather than a separate app you switch to.
Translation is handled in multiple modes and the choice is explicit. There is an offline translation plugin supported across all flavours, a built-in offline translation using ML Kit, and the configured cloud or self-hosted provider, with a fallback chain between them. In-keyboard translation means you can translate a phrase without leaving the app you were typing in.
OCR inside the keyboard, with a screenshot heuristic
The camera and screenshot OCR feature is the one that most changes how the keyboard behaves in practice, and it is worth separating the two parts.
The in-keyboard camera viewfinder opens a live camera preview directly inside the keyboard so you can extract printed or handwritten text with one tap. That is a different interaction from an OCR app: you never leave the app you were typing in, and the camera is a keyboard panel rather than a separate activity.
The screenshot suggestion pill is more automatic. It detects newly captured screenshots and displays a compact pill with three options, `[OCR] [Screenshot] [X]`, for immediate one-tap text extraction. That is a system-level observation, which is a meaningful thing for a keyboard to do.
Beyond the capture, there is the text cleaning side. The documentation lists advanced text cleaners and formatting with casing transformations, and the feature list also includes real-time inline math calculations, which compute a mathematical expression as you type it without leaving the input field.
The other listed capabilities in the same area are on-device Whisper voice typing, handwriting recognition, zero-latency custom sound packs, a smart toolbar that auto-spans, a built-in self-updater, and rich text tools. The self-updater is listed as a capability of the standard flavour in the comparison table, alongside the GitHub Releases based update checker, and the two are separate items in the feature list, which is a slightly confusing arrangement to read.
The project is also explicit about plugins being how most of this arrives. Voice typing, handwriting and OCR are all marked as via plugin in the flavour table, and the plugin setup is either an in-app download or a file import for the standard flavour, and a browser download plus file import for the offline one.
What survives from HeliBoard, and what the fork adds
The value of a fork like this is that the baseline is already good, and the fork's job is to add without breaking.
What comes from HeliBoard is the keyboard itself: the input method, the layout system, the dictionaries, the correction behaviour, the themes and the settings structure. The feature list in the README for LeanType adds the AI layer, the OCR layer and the productivity layer, and separately mentions a LeanType theme, with the `leantype-theme` in the project topics. The screenshots in the README cover Plugins and Capabilities, LeanType Settings, Voice Input Settings, Text Recognition Settings, Translation Settings, AI Integration, Appearance and Theme, Gesture Typing, and Suggestions and Correction, which is a good map of the settings surface.
The repository layout is a standard Android project with some additions. There is `app/`, `art/`, `docs/`, `tools/` and `fastlane/`, plus `layouts.md` at the root, which is a document about the keyboard layouts and is a useful reference for anyone who wants to know what layouts the fork ships. The build is Gradle with Kotlin DSL at the root in `build.gradle.kts`, with `settings.gradle` and `gradle.properties`.
The licence arrangement is worth noting because it is not a single file. There are three licence files at the root: `LICENSE`, `LICENSE-Apache-2.0` and `LICENSE-CC-BY-SA-4.0`. That pattern is the normal consequence of forking a project whose assets and code carry different terms, and it means the applicable terms depend on which part of the tree you take. The badge declares GPL v3. This is a licensing observation rather than legal advice, and the individual files govern.
There is also a `.jules/` directory at the root, an `AGENTS.md` is not present but a `CONTRIBUTING.md` is, and a `.editorconfig` for formatting.
Beta tags, a sponsor badge and two funding routes
The release history tells you what kind of project this is.
The three listed releases are all beta tags: beta-429-6 on 2026-10-13, beta-429-7 on 2026-10-14, and beta-429-8 on 2026-10-15. Three builds in three days, with a build number that increments each time. The last push was on 2026-10-15, the same day as the newest tag, and the repository is not archived.
So this is a project shipping continuous beta builds rather than numbered stable releases. That has consequences for a keyboard, because a keyboard is the component you cannot easily take back once installed and set as the input method. A beta build that is uploaded frequently is also a build that may be replaced frequently, and the project does provide a self-updater and a release update checker, but the decision about which build to sit on is yours.
The download guidance in the README is practical in a way that reflects how Android distribution actually works. It notes that Google Play Protect or your browser may block direct APK installations downloaded from web browsers, and it recommends installing via Obtainium or a package manager like App Manager.
The funding routes are a GitHub Sponsors badge pointing at the LeanBitLab organisation, and a Donate on Open Collective badge for the same organisation. The homepage is `leanbitlab.github.io/LeanBitLab/`, and the README links out to a list of other Android projects by the same group, which is the pattern of a group rather than a single maintainer.
The topic tags give a fair summary of what the fork is: keyboard, privacy, offline-ai, gguf-models, gemini-api, groq, proofreading, translation, aosp and customisation.
Editorial conclusion
LeanType fits an Android user who already likes HeliBoard and wants proofreading, translation and text extraction without leaving the keyboard, and who is either willing to use a cloud model provider or prepared to run a local GGUF model on the device. It does not fit a user who needs a stock, low-footprint keyboard, since the feature surface and the plugin downloads add weight that HeliBoard deliberately avoids, and it does not fit a user with an old device who wants offline AI, since that path requires Android 8.0 or later. Verify first that the flavour you install matches the behaviour you want, since the offline build has no cloud AI and no update checker while the standard build has optional internet permission, that the AI provider you point it at has a local or self-hosted option you actually want to run, and that the plugin you depend on for a given feature is available in the flavour you install.
Frequently asked questions
What is the difference between the LeanType standard and offline flavors?
The standard flavor has cloud AI through Gemini, Groq or OpenAI, an optional internet permission and a GitHub Releases update checker, and requires Android 6.0. The offline flavor has no cloud AI but runs local GGUF models through llama.cpp, has no internet permission at the OS level, and requires Android 5.0, with offline AI needing Android 8.0 or later.
How does LeanType run AI proofreading without sending my text to a server?
The offline flavor runs compact, quantized GGUF language models directly on the device through an embedded llama.cpp, which the project describes as 100% private with zero network access. The standard flavor instead supports cloud providers and self-hosted servers such as Ollama, LM Studio, LocalAI or vLLM.
What can the LeanType keyboard do with screenshots and camera images?
There is an in-keyboard camera viewfinder that extracts printed or handwritten text with one tap, and a screenshot suggestion pill that detects new screenshots and offers a compact `[OCR] [Screenshot] [X]` control for one-tap extraction. Advanced text cleaners and formatting with casing transformations are also included.
How do I install the LeanType APK without Play Protect blocking it?
The documentation notes that Google Play Protect or your browser may block direct APK installations from web browsers, and recommends installing via Obtainium or a package manager such as App Manager instead. Both flavors are published as separate APK files, `-standard-release.apk` and `-offline-release.apk`.
Is LeanType derived from HeliBoard?
Yes. The project states it is forked from HeliBoard, which is itself derived from OpenBoard and AOSP LatinIME. The license arrangement reflects that history, with a GPL v3 declaration and three separate license files at the repository root: `LICENSE`, `LICENSE-Apache-2.0` and `LICENSE-CC-BY-SA-4.0`.
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/leanbitlab-leantype)Was this useful?