Grammalecte Android — unofficial

A local, open-source French spelling and grammar checker for Android, powered by Grammalecte.

All correction runs on-device. The application does not request the Android INTERNET permission and does not use a cloud API or LLM.

Project status: the first public release candidate, 1.0.0-rc1, is available. The signed APK has passed reproducibility checks and seven manual acceptance tests on a Samsung Galaxy S21 / Android 15. Compatibility validation across other devices and applications is ongoing.

Download

Download Grammalecte Android 1.0.0-rc1

The release provides:

• a signed Android APK;
• a CycloneDX software bill of materials (SBOM);
• a SHA256SUMS file for integrity verification.

The application supports Android 8.0 (API 26) and later.

Download the APK from the release assets and install it using Android's package installer. Enable Grammalecte as the system spell checker, or use its selected-text correction and IME workflows described below.

Upgrading from a development APK: debug and release builds may use different signing certificates. Android cannot install an update signed with a different certificate. Back up application data before uninstalling an existing development build. The preferences export does not include personal dictionary entries.

This is a pre-release, not the final stable version. See the release notes for known compatibility limitations.

Current integration

Grammalecte Android currently exposes the same local correction engine through three Android integration paths:

1. SpellCheckerService

   • native Android spelling and grammar suggestions;
   • integrates automatically in applications that support the platform spell-checker framework.

2. ACTION_PROCESS_TEXT

   • adds a Corriger avec Grammalecte action to Android's selected-text menu;
   • opens a correction screen with explanations and individual suggestions;
   • can return corrected text to compatible applications;
   • offers Copier et revenir for read-only and editable selections; this copies the correction without modifying the source editor.

3. Grammalecte IME

   • a correction-oriented InputMethodService;
   • reads the currently selected text through InputConnection;
   • applies corrections directly to the active editable field;
   • provides a fallback for applications that bypass SpellCheckerService or ignore PROCESS_TEXT replacement results.

The current IME is intentionally focused on correcting selected text. It is not intended to replace a full-featured typing keyboard.

Why several integration paths?

Android applications do not all expose text correction in the same way.

A standard EditText can use Android's native spell-checker service, while some custom editors and web fields never call it.

PROCESS_TEXT works in many applications, but some editors do not accept returned replacement text.

For example, Samsung Messages may insert the correction immediately after the original selection instead of replacing it. The Grammalecte IME remains the preferred direct-replacement fallback in that application. See the compatibility matrix.

The IME fallback uses Android's normal InputConnection editing interface instead of an Accessibility Service. This keeps the replacement mechanism generic across editable applications while avoiding the broader permissions and privacy surface of accessibility automation.

Manual development tests have successfully applied real Grammalecte corrections in:

• Android native text fields;
• SMS editing;
• Samsung Notes;
• Firefox text fields.

Compatibility testing is documented in the reproducible compatibility matrix, including application versions, Android environment details and the integration path tested.

Architecture

The project is split into four Gradle modules:

Module	Responsibility
core	Pure Kotlin domain API: GrammarEngine, issues, ranges and normalization.
engine-grammalecte	QuickJS runtime, Grammalecte JavaScript bridge, dictionaries and mapping to the internal correction model.
spellchecker	Android SpellCheckerService integration and mapping to Android suggestion objects.
app	Application UI, setup tools, PROCESS_TEXT, IME integration and final Android packaging.

The correction engine remains isolated behind the GrammarEngine contract even though Android can reach it through several framework integrations.

See docs/architecture.md and docs/adr/ for the detailed design decisions.

Embedded Grammalecte engine

The repository vendors a pinned generated Grammalecte JavaScript runtime and Graphspell dictionaries.

The upstream revision is recorded in tools/grammalecte.env.

The current vendoring workflow is reproducible and tied to an immutable upstream commit.

Normal builds do not need to regenerate the engine.

Regeneration is only required when deliberately updating or rebuilding the vendored Grammalecte assets:

./tools/vendor-grammalecte.sh

Build

Development requirements:

• JDK 17;
• Android SDK 36 with Android Build Tools;
• Git;
• GNU Make;
• ShellCheck;
• curl;
• Node.js 20+.

Python 3.11 is only required when regenerating the vendored Grammalecte assets.

The Gradle wrapper is committed to the repository and is the source of truth for the Gradle version.

Run the same quality checks used by CI:

make check

Build the debug APK and verify its final permissions:

make assemble

Verify that two independent unsigned release builds are byte-for-byte reproducible:

make release-reproducibility

See docs/release.md for the complete release procedure.

A configured release-signing environment can also build and verify the signed release artifact with make signed-release.

Generate and validate the runtime CycloneDX SBOM with make sbom.

See docs/sbom.md for its scope and maintenance rules.

The debug APK is generated under:

app/build/outputs/apk/debug/

For development on a connected Android device:

./tools/run-android.sh

The script builds the debug APK, installs it with ADB and launches the application.

See CONTRIBUTING.md for the complete contributor workflow.

Activating the native spell checker

After installing the APK, open Android settings and select Grammalecte Android as the system spell checker.

The exact path depends on the Android distribution, but is generally similar to:

Settings
→ System
→ Languages and input
→ Spell checker

The application also provides a shortcut to the relevant Android settings screen.

Using PROCESS_TEXT

In a compatible application:

1. select some text;
2. open the Android text-selection menu;
3. choose Corriger avec Grammalecte;
4. review the detected issues and suggestions;
5. choose Remplacer le texte sélectionné when the source editor correctly handles replacement, or Copier et revenir to copy the correction;
6. when using the clipboard fallback in an editable field, manually select the original text and paste the correction; read-only content cannot be replaced through this action.

Using the Grammalecte IME

Android exposes the correction fallback as an input method named Grammalecte.

Once enabled in Android's keyboard/input-method settings:

1. select text in an editable field;
2. switch temporarily to the Grammalecte input method;
3. review and apply the proposed corrections;
4. switch back to the usual keyboard.

The first-run setup guide, activation status screen and keyboard-return workflow are implemented. Compatibility improvements continue based on release-candidate testing and reported issues.

Privacy invariant

The application intentionally declares no android.permission.INTERNET permission.

CI checks both the source manifests and the final packaged APK, and fails if android.permission.INTERNET appears after manifest merging.

This is particularly important for a spell checker or input method because selected or typed text can contain private messages, emails, searches and form data.

The current design therefore keeps correction entirely local:

Android text
    ↓
local Kotlin code
    ↓
embedded QuickJS runtime
    ↓
embedded Grammalecte engine
    ↓
local correction result

No text is sent to an external service.

Updating Grammalecte

Engine updates should be isolated and reviewable:

1. update GRAMMALECTE_COMMIT and GRAMMALECTE_VERSION in tools/grammalecte.env;
2. run ./tools/vendor-grammalecte.sh;
3. run the complete test suite;
4. inspect the generated asset diff;
5. verify upstream license metadata;
6. add or update regression tests when correction behavior changes.

Do not track an upstream branch dynamically at build time.

Automated checks

The repository contains GitHub Actions workflows for:

• Kotlin formatting and unit tests;
• Android lint;
• debug APK builds;
• privacy checks;
• shell script validation;
• JavaScript bridge contract tests;
• vendored Grammalecte engine smoke tests;
• Android instrumentation tests.

Dependabot monitors project dependencies, while the Gradle wrapper is deliberately updated manually because its version and distribution checksum are kept in sync with the project's bootstrap and CI configuration.

Contributing

Contributions are welcome.

Useful ways to help include:

• Android compatibility testing across devices, ROMs and applications;
• Kotlin and Android development;
• spelling and grammar regression fixtures using synthetic French text;
• automated tests and CI improvements;
• documentation and contributor tooling;
• build reproducibility and release engineering.

For non-trivial changes, open or reference an issue before starting significant work.

See CONTRIBUTING.md for development setup, project conventions and validation commands.

Project documents

• ROADMAP.md
• CHANGELOG.md
• CONTRIBUTING.md
• SECURITY.md
• THIRD_PARTY_NOTICES.md
• docs/architecture.md
• docs/testing.md
• docs/compatibility.md
• docs/release.md
• docs/sbom.md
• docs/fdroid.md
• docs/adr/

Name and affiliation

This is an unofficial Android integration of Grammalecte.

It is not affiliated with or endorsed by the Grammalecte project or Algoo.

The Android application ID and namespace are fr.zefut.grammalecte.

License

This project is licensed under GPL-3.0-only.

Grammalecte is distributed under GPLv3 and its upstream license information is preserved with the vendored sources and metadata.

QuickJS-KT is distributed under the Apache License 2.0.

See THIRD_PARTY_NOTICES.md.