We Want Better
Gatling 3.16 Brings GraphQL Load Testing, Shared Queues, and Better WebSocket Checks

Gatling 3.16 Brings GraphQL Load Testing, Shared Queues, and Better WebSocket Checks

October 31, 2026 3 min read

Gatling 3.16 adds a GraphQL SDK, shared queues for virtual users, HTTP QUERY support, standalone WebSocket checks, and more flexible client-certificate handling.


Gatling 3.16 adds several features for testing modern APIs and distributed systems. The release includes a GraphQL SDK for Java, Kotlin, and Scala, shared queues between virtual users, HTTP QUERY requests, and more flexible WebSocket validation.

Gatling's documentation currently lists version 3.16.0 as the latest version for local installation. The update targets teams testing systems that extend beyond a simple REST-over-HTTP model. GraphQL, event-driven services, WebSockets, and mutually authenticated connections each bring requirements that older load-testing approaches can handle awkwardly. ([docs.gatling.io](https://docs.gatling.io/reference/deploy/install-local/?utm_source=openai))

GraphQL testing moves into the core performance conversation

The largest addition is a GraphQL SDK for Java, Kotlin, and Scala. It handles queries and mutations over GET or POST, variables, operation names, checks against the data, errors, and extensions response members, and GraphQL error policies.

That support addresses a common weakness in status-only checks. A GraphQL server can return HTTP 200 when the requested operation has failed, so a load test that checks only the status code can report a false success. Gatling's GraphQL features allow teams to check the application result rather than treating transport success as proof that the operation worked.

The SDK also supports Automatic Persisted Queries and WebSocket subscriptions through the graphql-transport-ws protocol. Performance engineers can therefore test ordinary API traffic and long-lived subscription connections with the same tool. GraphQL is distributed as a separate dependency, and Gatling's documentation requires Gatling 3.16.0 or later. ([docs.gatling.io](https://docs.gatling.io/release-notes/gatling/whats-new/3.16/?trk=article-ssr-frontend-pulse_little-text-block&utm_source=openai))

Shared queues model more realistic user behavior

Shared queues let virtual users exchange values in Gatling 3.16. A user can add values to a named queue, then another can take or poll them, or inspect the queue size. This supports scenarios in which one simulated actor creates work and another consumes it.

A producer can submit jobs while worker users process them. One user group can generate payment or order identifiers for another, and separate populations can coordinate through an application-like handoff. Those patterns are difficult to represent when each virtual user keeps its data in an isolated session.

The queue still needs to match the behavior being simulated. Poorly designed synchronization can introduce effects that do not occur in production. A small proof of concept, followed by comparisons with production traces or service-level metrics, can show whether the queue reflects the intended workload.

Smaller protocol changes with practical value

Gatling now includes built-in support for the HTTP QUERY method. Unlike GET, QUERY can carry a request body while remaining safe and idempotent, making it relevant to emerging query-oriented API designs.

WebSocket checks can be configured independently with setCheck(). A test can wait for and validate a pushed message without connecting or sending a message in that same step. This fits notification systems, asynchronous updates, and services that send data after an earlier action.

Gatling also changes how tests can model mutual TLS. The perUserKeyManagerFactory option can use one PKCS#12 file with a key entry for each virtual user, eliminating the need for a custom function. That reduces setup code when every simulated client requires its own certificate. ([docs.gatling.io](https://docs.gatling.io/release-notes/gatling/whats-new/3.16/?trk=article-ssr-frontend-pulse_little-text-block&utm_source=openai))

What QA teams should test before upgrading

  • Build compatibility: confirm that Maven, Gradle, sbt, or JavaScript dependencies resolve the intended Gatling version and protocol components.
  • GraphQL error handling: add assertions for application-level errors, not just HTTP status codes.
  • WebSocket lifecycle behavior: verify connection, subscription, timeout, reconnect, and server-push scenarios separately.
  • Queue contention: measure whether producer and consumer virtual users remain balanced under peak load.
  • Certificate isolation: confirm that each virtual user presents the expected client certificate and that failed certificate selection appears in test results.

Gatling 3.16 is not a wholesale rewrite, but it expands the service interactions that teams can model without custom extensions. For teams already running HTTP performance tests with Gatling, the GraphQL and coordination features provide the strongest reasons to evaluate the upgrade.

Looking for tools to match this read?

Jump into our independent side-by-side comparisons.

Compare Tools