Open-source project
gatling/gatling avatar
gatling/gatling

gatling/gatling: load testing as code, and the parts the README leaves out

Modern Load Testing as Code

6,961 stars1,209 forksScalaApache-2.0

At a glance

What is it?
Gatling is an Apache-2.0 load testing platform whose tests are written in Java, JavaScript, TypeScript, Kotlin or Scala. It is a strong fit for engineers who want version-controlled performance tests, and a poor fit for anyone who wants a GUI-first workflow.
Who is it for?
Adopt Gatling if your team already keeps test code in a repository and wants performance runs to be reviewable artifacts. Do not adopt it if you need a point-and-click tool with no build step, or if you expect the open-source distribution to give you the dashboards, SSO and quota features the README attributes to Gatling Enterprise Edition.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 4 days ago.
What is it written in?
Mainly Scala, 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

  • gatling/gatling6,961 ★ · +3
Star history
Repository2026-09-232026-11-15
gatling/gatling7k7k

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

Editorial analysis

The problem Gatling solves, and who ends up using it

Load tests that live in a GUI tend to rot. The scenario is stored in a proprietary format, nobody reviews changes to it in a pull request, and the only person who can edit it is the person who built it. Gatling's answer is to make the scenario a source file. The README describes it as an open-source load testing tool: you write scenarios ("simulations") as code, run them against your services, and get a detailed HTML report of response times, throughput, and errors, with tests written in Java, JavaScript, TypeScript, Kotlin or Scala.

The intended audience is narrow and specific. The README's 'Why Gatling' section targets the same pains: thread-per-user tools that need a fleet of load generators, and proprietary XML formats with an export step between a GUI and your pipeline. If none of those sentences describe your situation, the code-first premise buys you nothing and costs you a build step.

This repository ships HTTP/1.1, HTTP/2, WebSocket, Server-Sent Events and JMS under Apache 2.0; gRPC, MQTT and GraphQL are listed separately in the README. That list matters more than any feature bullet, because it decides whether Gatling can talk to your system at all. A team testing a proprietary binary protocol over raw TCP will not find it here.

Non-blocking IO and the module layout behind it

The architectural claim in the README is that legacy tools rely on blocking IO and one-thread-per-user designs, which forces teams to run large farms of injection servers, while Gatling uses a non-blocking, asynchronous architecture to get more load per node. The repository layout supports that story: there is a gatling-netty-util module and a gatling-http-client module, so the HTTP path is built on Netty rather than on a thread pool sized to the virtual user count.

The code is split by concern and by language. gatling-core holds the simulation engine and gatling-core-java is the Java-facing layer; gatling-http and gatling-http-java mirror each other the same way, as do gatling-jdbc, gatling-jms and gatling-redis against their -java counterparts. gatling-charts handles report rendering, gatling-recorder is the browser session recorder the README mentions, and gatling-test-framework is the piece that lets a simulation run as a test. The build is a single build.sbt, and the primary language is Scala, which is worth knowing before you file an issue about the build.

That split is the real design decision. The engine is Scala, the ergonomics are per-language wrappers, and the two are versioned together in one repository. The JavaScript SDK, however, lives in a separate repository (gatling/gatling-js) and drives the same engine; only the Java SDK (Java, plus Kotlin and Scala on the JVM) is in this repository.

Installing Gatling and running a first simulation

The README points to the official tutorials at docs.gatling.io and links a Java JVM installation guide and a JavaScript installation guide. It states the Java SDK works with any OpenJDK LTS release from 11 to 25, with Maven, Gradle, or sbt. Treat the tutorial as the source of truth rather than any snippet you find elsewhere.

What the README does commit to is the shape of a test: a simulation written in one of the supported languages, using the SDK for that language. The repository names the modules that back each surface, so a Java project depends on the Java artifacts and a JavaScript or TypeScript project goes through the JavaScript installation path. The Gatling Maven Central badge in the README points at io.gatling:gatling-core, which is the coordinate to look up when you need to confirm what is published.

Once a simulation exists, the workflow the README describes is: run it, compare the run against previous runs to detect regressions, and optionally enforce a performance gate in CI. The open-source repository provides the engine, the recorder, the charts and the test framework integration.

bash
./mvnw gatling:test

The README includes a complete Java simulation (BasicSimulation, which sends 10 users to one endpoint and fails if any request fails); put it in src/test/java/example/ of the Maven starter project and run the command above.

Where Gatling is the wrong tool

The README is candid about one boundary by omission: the features that make Gatling attractive to managers are in the Enterprise Edition. Real-time dashboards, trend analysis, SLO monitoring, AI-assisted summaries, APM integrations, role-based access control, SSO, quotas, shared reports, Slack, Teams and Jira integrations, and low-code or no-code test creation are all listed under Gatling Enterprise Edition or under the collaboration and governance heading. The open-source distribution is the engine, the SDKs, the recorder and the charts.

That is a genuine limitation, not a marketing quirk. In the Apache-2.0 build, gating means assertions on response times and error rates that fail the build when a threshold is breached; check the Enterprise Edition section before promising anything beyond that.

There is a second boundary: the code-first premise. If your organization has no build pipeline for the test project, no repository discipline, and no one willing to own a Scala-based engine's upgrade path, a GUI tool will get you a first result faster. Gatling assumes a team that treats performance tests as software. Teams that do not will spend their time on tooling instead of on load.

Gatling against JMeter and k6, in approach rather than in features

The obvious comparison is Apache JMeter, and the difference the README draws is architectural rather than cosmetic. JMeter's classic model is thread-per-user with blocking IO, which is why large tests get distributed across many machines. Gatling's non-blocking Netty-based client is designed to keep more virtual users on one node. The practical consequence is that Gatling's capacity planning conversation is about one machine's limits, while JMeter's is often about how many remote workers you can coordinate.

The second comparison is k6, which also puts tests in code and targets CI. The difference here is the language surface and the runtime. Gatling offers Java, JavaScript, TypeScript, Kotlin and Scala SDKs over a Scala engine on the JVM, which suits teams already standardized on the JVM and its tooling. k6 is JavaScript-first on a Go runtime. Neither choice is better in the abstract; the deciding question is which language your engineers will actually maintain, and whether your build agents already have that runtime installed.

A third point of difference is the recorder. Gatling ships gatling-recorder in the repository, so browser sessions can be captured and exported to code, which shortens the gap between a manual walkthrough and a scripted scenario. The README also mentions building tests visually and exporting to code, but that sits closer to the Enterprise feature list than to the open-source core.

Maintenance, licensing and what an upgrade actually costs

The repository is not archived, and the last push was on 2026-11-02. That is a live codebase, and the presence of .scala-steward.conf indicates automated dependency updates are configured, which matters for a JVM project with a Netty-based client underneath it.

The licence is Apache-2.0, stated plainly near the top of the README and present as LICENSE.txt and a NOTICE.md at the repository root. Apache-2.0 is permissive: you can use the engine commercially and modify it, and the NOTICE file is the mechanism for attribution. What the licence does not cover is the Enterprise Edition, which is a separate product with separate terms, and the README does not describe those terms. If your organization's legal review depends on knowing exactly which features fall on which side of that line, the README is not sufficient documentation and the licensing page is the place to look.

The upgrade cost is the part teams underestimate. Because the engine is Scala and the SDKs are per-language layers, a major version bump can move the simulation DSL, not just the dependency version. The repository keeps gatling-core-java, gatling-http-java, gatling-jdbc-java, gatling-jms-java and gatling-redis-java as separate modules, so a Java user's compile errors will point at the Java layer while the underlying change may be in the core. Budget for reading release notes rather than for a version-string edit.

Editorial conclusion

Adopt Gatling if your team already keeps test code in a repository and wants performance runs to be reviewable artifacts. Do not adopt it if you need a point-and-click tool with no build step, or if you expect the open-source distribution to give you the dashboards, SSO and quota features the README attributes to Gatling Enterprise Edition. Before committing, open the Java JVM or JavaScript installation guide at docs.gatling.io and confirm that a supported JDK is available on your build agents; the README lists any OpenJDK LTS release from 11 to 25.

Frequently asked questions

What is Gatling used for?

Gatling is an open-source load testing platform for simulating real-world traffic, validating system behavior under load and detecting regressions before a release. This repository ships HTTP/1.1, HTTP/2, WebSocket, Server-Sent Events and JMS, and runs in CI through Maven, Gradle, sbt, or npm plugins.

How to use Gatling for performance testing?

You define the test as code in Java, JavaScript, TypeScript, Kotlin or Scala using the SDK for that language, then run the simulation, read the HTML report, and use assertions to fail the build on regressions. The README directs new users to the official tutorials at docs.gatling.io, which cover the Java JVM and JavaScript paths.

How to install Gatling on Windows or macOS?

The README does not list platform-specific install commands. It links to an official Java JVM installation guide and a JavaScript installation guide at docs.gatling.io, and those guides are where the setup steps for each operating system live.

Official sources

  1. gatling/gatling on GitHub
  2. Issues
  3. License: Apache-2.0
  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/gatling-gatling.svg)](https://hysenlabs.com/projects/gatling-gatling)

Star history chart for your README

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

Was this useful?