Self-hosted service
languagetool-org/languagetool avatar
languagetool-org/languagetool

LanguageTool: self-hosted grammar checking with a Java server and a plain HTTP API

Style and Grammar Checker for 25+ Languages

15,262 stars1,603 forksJavaLGPL-2.1

At a glance

What is it?
LanguageTool is an LGPL-2.1 proofreading engine for 25+ languages that you can run yourself. This covers the install script, the HTTP API, the build cost, and when a hosted checker is the better call.
Who is it for?
Adopt LanguageTool when you need grammar checking to run on your own hardware, in a language other than English, or behind an HTTP API you control; the LGPL-2.1 core and the server module make that possible without a commercial agreement. Skip it if you want a managed service with no JVM, no 500 MiB clone and no rule-tuning, because none of that is in this repository.
Can I use it commercially?
Yes, with conditions. LGPL-2.1 is a weak copyleft licence: you can use it inside commercial and closed-source software, but if you distribute changes to its own files, you must publish those changes under the same licence.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Java, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • languagetool-org/languagetool15,262 ★ · +200
Star history
Repository2026-09-212026-11-15
languagetool-org/languagetool15.1k15.3k

200 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The gap LanguageTool fills: errors a spell checker cannot see

A spell checker answers one question: is this token a word? LanguageTool answers a different one. The README states it "finds many errors that a simple spell checker cannot detect," which is the whole reason the project exists. That means agreement errors, wrong-word substitutions, and style patterns, not just typos. The target user is not a novelist looking for a nicer adjective. It is an engineer or a team that needs proofreading inside a pipeline, an editor, or an internal tool, and needs it in a language other than English. The README lists English, Spanish, French, German, Portuguese, Polish and Dutch explicitly, then points to more than 20 others on the languages page. That breadth is the differentiator. Most checkers of this class are strong in English and thin elsewhere; LanguageTool's rule sets are split into per-language modules under languagetool-language-modules. The second differentiator is deployment. The core is available under LGPL 2.1 or later, so you can run the checker on your own machine, in your own network, without sending text to a third party. For anyone handling contracts, medical notes, or unreleased source code, that is not a nice-to-have.

How the engine is put together: core, language modules, server, clients

The repository layout makes the architecture legible without reading a design document. languagetool-core holds the checking engine. languagetool-language-modules holds the per-language rule and dictionary data, which is why a build pulls so much: the rules ship with the code. languagetool-server wraps the core in an HTTP service. languagetool-commandline is the batch entry point, languagetool-gui-commons backs a desktop interface, languagetool-office-extension is an office extension, and languagetool-wikipedia is a separate packaging aimed at wiki text. There are also languagetool-http-client and languagetool-client-example, so you can call a running server from Java without hand-rolling requests. The README links the HTTP API documentation as a Swagger UI page and a separate Java API page with Javadoc for JLanguageTool. That split matters operationally. If you only need checking, the server plus HTTP is enough and you never touch the Java API. If you are embedding the engine in a JVM application, languagetool-core is the dependency and no server is involved.

Installing LanguageTool with install.sh and running a first check

The README offers a scripted path. The one-liner downloads install.sh from the master branch and pipes it into sudo bash, so read the script before running it. The -c flag specifies a post-installation command to run, and the default is gui when a screen is detected.

sh
#!/usr/bin/env sh
curl -L https://raw.githubusercontent.com/languagetool-org/languagetool/master/install.sh | sudo bash $options

The same script accepts options when downloaded and run directly. The README gives the usage as:

sh
sudo bash install.sh <options>

For a build from source, the README requires Java 17 and Apache Maven. A full clone is large, so the shallow form is the practical one:

sh
git clone --depth 5 https://github.com/languagetool-org/languagetool.git

Then, from the root project folder, compile and test, and package the standalone distribution:

sh
mvn clean test
./build.sh languagetool-standalone package -DskipTests

The README says to test the result in languagetool-standalone/target/. The build script also packages languagetool-wikipedia, with output in languagetool-wikipedia/target. Note the warning attached to source builds: the README calls the result a "bleeding edge development copy" that "might contain regressions." That is a fair description of master.

Docker is community-maintained, not part of the core repository

The README does not ship a Dockerfile. It points to three community projects instead: meyayl/docker-languagetool published as meyay/languagetool on Docker Hub, Erikvl87/docker-languagetool published as erikvl87/languagetool, and silvio/docker-languagetool published as silviof/docker-languagetool. The README explicitly calls these "community-contributed." The consequence is concrete. Their image tags, base images, exposed ports and upgrade cadence are set by their maintainers, not by the LanguageTool project, and nothing in this repository guarantees they track the core. If you deploy one of these images, you own the question of which LanguageTool version is inside it, and you should verify that yourself. The upside is real: a container avoids the Java 17 and Maven setup entirely, and for a service you want to restart on demand, that is usually the right trade. The cost is that your supply chain now has a second maintainer in it.

Where LanguageTool is the wrong tool

The build cost is the first honest limitation. The README states that a complete clone requires more than 500 MiB of download and more than 1500 MiB on disk. The shallow clone reduces that to under 60 MiB and under 200 MiB, so the constraint is manageable, but it tells you what the project is: a rule corpus, not a small library. The second limitation is rule quality variance. Because coverage is split across language modules, the experience is not uniform across the 25+ languages. A rule set that is mature for German or English may be sparse for a language with fewer contributors, and the README does not publish per-language accuracy figures. If your language is not one of the seven named in the README, verify coverage on real text before you plan around it. The third limitation is that the core is a checker, not an editor. It returns matches; it does not rewrite a document, manage style guides per team, or integrate with a writing workflow on its own. Everything above the match list is your code.

LanguageTool against Grammarly and the hosted-checker model

The common comparison is LanguageTool versus Grammarly, and the difference is architectural rather than a matter of which catches more commas. Grammarly is a hosted product. Your text leaves your machine, the model lives with the vendor, and pricing, language support and feature set are set by that vendor. LanguageTool's core is LGPL-2.1 software you can run yourself, including offline. The trade runs both ways. Self-hosting means you carry the JVM, the disk footprint, the rule updates and the server operation. It also means no per-seat billing and no text leaving your network. Whichever route you take, the engine underneath is the same Java code in this repository.

License, upgrade cost and what the LGPL-2.1 core implies

The README states that the LanguageTool core is distributed under the LGPL 2.1 or later, with COPYING.txt at the repository root. The README also qualifies this with "unless otherwise noted," which is a signal that not every file in the tree necessarily carries the same terms. If you plan to redistribute a modified build, read COPYING.txt and the headers on the files you touch rather than assuming the whole tree is uniform. This is not legal advice; it is a pointer to where the answer lives. On upgrades, the repository gives you the mechanics and not a schedule. build.sh, build-zip.sh, create_snapshot.sh, deploy_release.sh and do_release.sh are all present at the top level, and CHANGES.md is linked from the README for release history. The maintenance cost you should budget for is the rebuild loop: a Java 17 toolchain, Maven, and a package step every time you want a newer rule set. Teams that pin a version and rebuild quarterly will find that cheap. Teams that expect the server to update itself will not find that here.

Editorial conclusion

Adopt LanguageTool when you need grammar checking to run on your own hardware, in a language other than English, or behind an HTTP API you control; the LGPL-2.1 core and the server module make that possible without a commercial agreement. Skip it if you want a managed service with no JVM, no 500 MiB clone and no rule-tuning, because none of that is in this repository. Before committing, clone shallow, run mvn clean test, start the server, and confirm your target language has the coverage you expect.

Frequently asked questions

Is LanguageTool still free?

The README states that the LanguageTool core in this repository is freely available under the LGPL 2.1 or later. That covers the engine and the server you run yourself. It says nothing about the hosted service on languagetool.org.

What is LanguageTool used for?

It is open-source proofreading software that finds errors a simple spell checker cannot detect, across English, Spanish, French, German, Portuguese, Polish, Dutch and more than 20 other languages. It can be used through a GUI, a command line, an HTTP server, or an office extension.

How do I install LanguageTool?

The README's scripted path downloads install.sh from the master branch and runs it with sudo bash, passing options for build, package and post-install command. Alternatively, install Java 17 and Apache Maven, clone the repository, run mvn clean test, and package with ./build.sh languagetool-standalone package -DskipTests.

Is LanguageTool better than Grammarly?

The repository does not publish accuracy comparisons, so that cannot be answered from what it documents. The verifiable difference is deployment: LanguageTool's core is LGPL-2.1 software you can run on your own server or offline, while Grammarly is a hosted product.

Official sources

  1. Issues
  2. languagetool-org/languagetool on GitHub
  3. License: LGPL-2.1
  4. Project website
  5. README
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/languagetool-org-languagetool.svg)](https://hysenlabs.com/projects/languagetool-org-languagetool)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/languagetool-org-languagetool.svg)](https://hysenlabs.com/projects/languagetool-org-languagetool)

Was this useful?