BreakTest is a modern, JMeter-compatible performance testing tool.
It started as an independent fork of Apache JMeter and continues the familiar JMX workflow with a leaner runtime, current protocols, better debugging, and a faster development loop. Existing JMeter test plans remain important, but BreakTest is not intended to be a frozen copy of JMeter.
Apache JMeter gave the performance testing community a durable model: test plans, samplers, controllers, assertions, extractors, listeners, and a file format people can keep in version control.
BreakTest keeps that useful model and moves the runtime forward:
- lower memory and CPU pressure for large HTTP tests
- HTTP/2 and a modern HTTP client stack
- Java 21+ and virtual-thread support
- a more modern GUI with simple light/dark themes
- better GUI feedback while building, debugging, and repairing scripts
- safer loading of old plans and plugin-heavy JMX files
- AI-assisted scripting with Codex, Claude Code, Cursor Agent, Gemini CLI, Pi Code, OpenCode, Copilot CLI, and MCP workflows
- an open-source Community edition that can be scaled by BreakTest Enterprise when one machine is no longer enough
Compared with the upstream baseline this work has already shown about 50% lower memory usage, with CPU reductions around 20-50% depending on workload, test shape, and runtime conditions.
BreakTest Community is the open-source desktop and runtime distribution, licensed under Apache-2.0. Commercial use, modification, redistribution, and hosting are permitted subject to that license's terms.
BreakTest Enterprise is the paid shell around scaled execution and analysis. It runs BreakTest, JMeter, and k6 tests across your own infrastructure with distributed load generators, realtime results, raw data retention, reports, SLO validation, team workflows, and AI-assisted analysis.
BreakTest Enterprise is a separate product under a commercial license. Its proprietary components are not covered by the Community Apache-2.0 license. Community use, including commercial use, does not require an Enterprise license.
BreakTest is based on the JMeter workflow, but it makes deliberate changes where that helps day-to-day performance engineering. The initial Community release is not just a rename: it includes protocol, runtime, GUI, AI scripting, debugging, and migration work that has landed across the BreakTest PR series.
- Apache HttpClient 5 is the active HTTP sampler path.
- HTTP/2 is first-class, including negotiated fallback, HTTP/2 preferred selection, async execution, connect-time reporting, and file upload fixes.
- HTTP/3 over QUIC is available as a beta on Java 27+, with explicit HTTP/3 selection and optional browser-like Alt-Svc upgrades for default samplers.
- HTTP/2 resource usage is lower: reactor threads are limited by default, client rebuilds are avoided when the same user continues, and parallel samplers reuse HTTP state deterministically.
- HTTP/2 closed-session retry handling covers common HC5 connection-closure failures without reusing dead multiplexed sessions.
- NTLM authentication works on the HttpClient 5 path, including variable resolution before async challenge callbacks.
- Modern response decoding includes gzip, deflate, Brotli, and Zstandard.
- Timeout errors are reported more clearly, with expected connect/response timeouts shown as concise messages instead of noisy stack traces.
- HttpClient 4 runtime jars are still bundled for legacy plugin compatibility, while the built-in HTTP Request sampler stays on the modern client path.
- Lazy response decompression avoids paying decompression cost unless response data is actually inspected.
- Response retention modes can store compressed data, discard successful bodies, keep only failing bodies, or retain checksums instead of full payloads.
- Lightweight test-plan cloning reduces per-thread object churn for large plans.
- Per-sample metadata is lazy, so rich diagnostics are only stored when listeners such as View Results Tree need them.
- Header merging, temporary property handling, and per-thread scratch buffers reduce hot-path allocations.
- Java 21+ and virtual threads are used where they reduce runtime overhead.
- Parallel Controller models browser-like concurrent requests with bounded parallel sampler execution and HTTP state safeguards.
- Fork Controller runs a child branch asynchronously while the main virtual-user flow continues, sharing the same context and variables. At each main-flow iteration end, choose immediate stop without cancellation errors, graceful stop after current samplers, wait for the entire fork, or keep running into the next iteration. Keep running is offered only when the enclosing thread group enables "Same user on each iteration" (or when editing a reusable fragment without a thread group) and has a separate graceful/immediate stop choice for the final iteration or duration limit. When the same fork is reached while still active, choose skip, hard restart, or wait then start again. Controllers default to graceful stop at iteration end and skip on re-entry, including code-created controllers and plans without lifecycle settings. Fork errors have their own policy, independent of the thread group's sampler-error setting: continue, stop this fork (including nested forks) and continue the main flow, end the main iteration gracefully, or end the main iteration immediately without cancellation errors. The default is Continue on error, including plans without an explicit error policy. Graceful stop finishes active requests; immediate stop interrupts them. Both iteration-end choices end all forks belonging to that user, retain the original failed sample, and allow the next configured main iteration to run. Transactions cut short by these fork errors are reported as failed; cancellation before any sampler starts produces no empty summary. Transaction-start events reach listeners at the first sampler for all transactions (naturally empty transactions report start at completion). A keep-running fork that fails during pacing ends the iteration that is just starting. During immediate iteration cancellation, results and control exceptions from cancelled samplers are suppressed; this can also swallow a concurrent explicit stop-test request from those samplers. External engine stop-test requests are unaffected.
- Standard Thread Group can switch between closed and open workload models.
- Open model scheduling offers constant and ramp phases with even or random arrivals, maximum active thread limits, and graph preview support.
- Closed model phases let you combine different ramp-up speeds, hold periods, and thread targets, making it possible to shape almost any closed workload model from one schedule.
- Thread Group pacing controls apply pacing between iterations.
- Runtime user variables are cleared on new iterations when same-user mode is disabled, while initial variables remain available.
- Pause and Resume are available in the GUI and in headless runs through the same UDP command port used for shutdown, stop, heap dump, and thread dump commands. This makes it possible to pause a schedule during ramp-up and hold the current load instead of ramping further. In closed model, active threads are kept as-is. In open model, new arrivals are paused and active threads finish naturally, so load drops while the schedule is paused.
- Shutdown is quicker because it no longer waits for timers to complete. It still waits for in-flight server responses, so active requests can finish cleanly.
The schedule table has From (threads/min), To (threads/min), Duration (seconds), and Random arrivals columns. Leave To blank to use the From rate, or enter the same value for a constant rate. Different values produce a ramp. Viewing a schedule or switching between table and text views preserves its original text. After a table edit, equal rates use a constant function, and the optional flag is written only for random arrivals:
constantThreadsPerMinDuring(120, 30)
rampThreadsPerMinDuring(120, 300, 60, true)
constantThreadsPerMinDuring(0, 10)
Rates are threads per minute; durations are seconds. The final flag selects even
arrivals (false) or random start times (true). Random mode keeps the planned
arrival count for each phase and distributes its start times according to the
constant or ramping rate. Use a nonzero random seed to reproduce the same timing.
A zero-rate phase pauses new arrivals while existing threads finish naturally.
Existing constant functions still load correctly. Omitting the flag in older
constant/ramp functions still means even arrivals. Even-arrival edits retain the
syntax supported by earlier BreakTest releases. The random flag requires this
version; compatibility with standard Apache JMeter is not implied.
Numeric table cells reject empty required values, negative numbers, decimal commas, and other invalid input. Closed-model cells require whole numbers. Converted rates retain their full precision to preserve arrival timing. Comments and advanced expressions use the text view, which is selected automatically when needed.
When opening a JMX, BreakTest converts literal legacy rate, even_arrival,
random_arrival, and pause schedules into these phases, preserving their timing
and arrival distribution. Comments remain available in Edit as text. Migration
runs for both current and legacy open-model thread groups, including headless
loads, and does not rewrite the source file until you save. Unresolved variables,
invalid schedules, and schedules that cannot be converted without changing the
workload remain unchanged; the runtime still accepts legacy syntax.
- The GUI uses a cleaner FlatLaf-based look with simple light and dark themes, giving the desktop a more harmonized modern feel without changing the core workflow.
- Undo and redo are enabled for semantic test-plan changes such as add, delete, update, move, and search/replace operations.
- Large JMX files load in the background with a loading overlay.
- Fast GUI loading is enabled by default, avoiding expensive initialization of
every element editor. Set
breaktest.gui.load.fast=falsefor compatibility with components that require editor initialization on load. - JMX files with missing plugin elements can open with disabled placeholders instead of failing the whole load.
- Missing plugin placeholders are visible in the GUI and inert in non-GUI runs.
- Search can flag pre-processors, post-processors, assertions, timers, and config elements.
- Search results can be selectively removed with confirmation, so bulk cleanup is possible without deleting parent elements accidentally.
- GUI validation skips artificial transaction delay and pacing sleeps.
- BreakTest can run AI-assisted script repair from the GUI or through local agent tooling.
- The agent workflow works with tools such as Codex, Claude Code, Cursor Agent, Gemini CLI, Pi Code, OpenCode, and Copilot CLI through BreakTest's MCP server and command-line helpers.
- AI repair can inspect a failing or incomplete test plan, run bounded validation, and apply concrete JMX edits instead of only suggesting changes.
- The repair flow can add extractors, parameterize dynamic values, improve correlations, add assertions, and professionalize recorded scripts so they are easier to maintain.
- GUI support highlights the changes made during repair, making it easier to review what was added, changed, or removed.
- Project-local AI knowledge can be stored with the test plan so recurring conventions, application details, and scripting assumptions travel with the work.
- If and While Controllers support structured condition rows with all/any matching, while legacy expression mode remains available for old plans.
- Loop and While Controllers expose clearer index behavior and exported index variable display.
- Transaction Controller has clearer measurement modes plus built-in delay and pacing options with fixed, random, and Gaussian modes.
- Boundary, CSS/HTML, Regex, XPath, XPath2, JSONPath, and JMESPath extractors can fail the sampler when no value is found.
- CSV Data Set can read records in random order while preserving header behavior.
- CSV preview shows the first variable assignments before running the test.
- Tools > Archive browser imports and exports shared files stored under
files/in the JMX archive. Use Replace file to select new contents for an existing file without changing its archive path or references. Importing an existing filename also asks to replace it. Changes take effect in the archive on Save, which retains the previously saved contents in version history. - Tools > Version History opens the test plan's Versions tab, which lists previous saves and supports opening
a version or deleting selected versions. The Archive browser starts at the root; double-click a folder
to browse its contents and use Up to return. The
versions/directory is visible there too. Opening preserves the saved latest plan until the next save, which keeps that plan as another version. Versions share unchanged attachments by SHA-256 checksum. Changed or removed files are kept while any version needs them; deleting versions removes historical content only when no remaining version needs it. Version sizes show the stored plan and reference manifest, excluding shared attachment content. Existing full snapshots are converted to shared storage on save or version deletion. Save the test plan after importing files. CSV Data Set and HTTP file uploads can select files from the archive using their archive-source flags. For other fields that accept functions, use${__archiveFile(filename)}to obtain a local path to an archived file. Fields resolved by FileServer also acceptarchive:filename(this prefix is not a general filesystem path). Files are shared by archive name; editing a file updates every reference to it. The browser's Delete action removes shared files from the next saved archive; references to deleted files fail. Plans with missing or corrupt indexed files still open with a warning. Those files appear as Unavailable in the archive browser; restore the matching file or delete its entry before saving. Pasted CSV configurations whose files are absent from this plan's index produce a warning; import those files explicitly. Deleted files are not automatically restored from element metadata. New shared filenames must be portable across macOS, Windows, and Linux: Windows reserved names, characters, and trailing dots/spaces are rejected without silently renaming the file. The built-in CSV editor accepts at most 128 MiB, reduced to one twelfth of the JVM heap limit on smaller heaps. Larger files can be exported, edited externally, and imported again. JMX saves replace the destination only after serialization succeeds, preserving existing POSIX permissions; new files use normal permissions subject to the process umask. Archive portability covers local GUI and CLI execution. RMI Remote Server execution is not supported. External orchestration must make the JMX archive available to each BreakTest process. The browser's Clean up recordings action can remove static-resource bodies, static-resource recordings, or all recorded headers and bodies. Its orphan cleanup removes exchanges without sampler references and unused recording blobs; shared files are preserved. Review the estimated reduction before applying cleanup, then save the plan. - JSR223/Groovy is the intended scripting direction; legacy BeanShell, BSF, JEXL2, Rhino JavaScript, and LogKit paths are removed.
- View Results Tree shows richer request/response diagnostics, endpoint data, HTTP/TLS metadata, cookies, variables, binary/text detection, and jump-to-source.
- Rendered response views and raw text response views have separate lifecycle handling, so switching renderers shows the expected data.
- BreakTest JMX saves origin metadata used by newer debugging tools.
- HAR-backed recorded exchange views can show recorded request and response data next to replayed samples.
- Recorded-vs-replayed diffs help debug HAR migration and HTTP/2 replay issues.
- Transaction child samples preserve source paths so recorded exchange diffs can still navigate to the right test element.
- HTTP/2 HAR replay strips unsupported hop-by-hop headers and normalizes request/status lines for clearer comparisons.
- Host-only cookie matching is stricter so cookies do not leak to unrelated hosts or subdomains.
BreakTest removes or de-emphasizes old paths that make the runtime harder to maintain. That includes legacy HTTP implementations, old scripting engines, LogKit, and RMI Remote Server style distributed execution.
For local use, run BreakTest directly. For distributed execution, use BreakTest Enterprise or another controlled orchestration layer rather than reviving the old Remote Server model.
BreakTest intentionally keeps many JMeter names in package names, properties, file formats, command internals, and Maven coordinates. This preserves compatibility with existing test plans, plugins, scripts, and integrations.
Some compatibility limits are intentional:
- plugins that depend on removed internals may need migration
- legacy scripting engines are not a long-term direction
- new BreakTest JMX features may not round-trip into old JMeter versions
- Java 21 or later is required
The goal is a better tool for current performance engineering, not perfect preservation of every old edge case.
- Java 21 or later; CI covers Java 21, 25, and 27
- HTTP/3 requires Java 27 or later, with HTTP/3 and TLS coverage on Java 27
- A JDK is recommended when recording HTTPS traffic because
keytoolis useful for certificate handling - Optional protocol libraries, such as JDBC or JMS drivers, should be placed in
liborlib/optas needed
Unpack the binary distribution, then start BreakTest from bin:
cd breaktest/bin
./breaktestOn Windows:
breaktest.batFor non-GUI execution:
./breaktest -n -t test-plan.jmx -l results.jtlThe GUI checks for a new stable GitHub release at most once every 24 hours. You can also check immediately with Help > Check for Updates. When a new version is available, an update button appears in the status bar. BreakTest downloads the binary release, verifies both its GitHub SHA-256 digest and its published SHA-512 checksum, installs it after the GUI exits, and then restarts.
Self-update is available from writable binary installations. Source checkouts
are never modified by the updater. Updates preserve bin/user.properties,
bin/system.properties, non-core plugins in lib/ext, and user-installed JARs
such as JDBC/JMS drivers in lib or lib/opt. Set
breaktest.update.enabled=false in user.properties to disable automatic
checks, or change breaktest.update.interval_hours to adjust their frequency.
Some internal property names, package names, and artifact names still use
jmeter for compatibility.
The BreakTest Browser Recorder is a separate project with its own validation, packaging, releases, and browser store submissions. Install and update it independently from BreakTest; it exports local HAR files that BreakTest can import through File > Import HAR....
HAR import excludes requests explicitly marked as served from browser cache. For older Chromium recorder exports that missed memory-cache markers, it also recognizes repeated cache reuse and first-occurrence entries with the old recorder's combined stale-size, inconsistent-timing, and sparse-header signature. Short duration or zero transferred bytes alone do not identify a cache hit; ambiguous entries remain replayable. Updating the recorder provides explicit cache metadata for future recordings.
BreakTest uses Gradle and JVM toolchains.
Build and test:
./gradlew buildBatch integration checks run in three parallel groups after the shared distribution
and extra test libraries have been prepared. JMS exclusively owns port 61616,
bin/activemq-data, and bin/JMS_TESTS.* outputs. A separate local regression group
runs controller, extractor, and result-action fixtures with in-process samplers,
read-only inputs, and distinct output files. Both groups disable the unused UDP
shutdown listener. Each fixture still runs in its own JVM, and each group runs
serially internally. The remaining protocol fixtures stay together: HTTP variants
reuse output files, while FTP/TCP fixtures share ports. Intentional waits and all
assertions remain unchanged. Use --no-parallel to serialize the groups for
diagnostics. Existing :src:dist-check:batch... task paths remain available.
Create local bin and lib contents for development:
./gradlew createDistRun the GUI through Gradle:
./gradlew runGuiCreate release archives:
./gradlew clean :src:dist:distTar :src:dist:distZip -PreleaseRelease versions are configured in gradle.properties:
breaktest.version=2026.11.10Do not include -SNAPSHOT in that property. Gradle appends the snapshot suffix
automatically unless the build is run with -Prelease or -Prc=<number>.
Type ${ in a test component editor to see available variable names. Keep typing
to filter the list, use Up/Down to select, Enter or Tab to insert, or Escape to dismiss.
This also works when typing into a selected table cell, in multiline editors, and
in expanded text dialogs. JSR223 script bodies are excluded so Groovy string
interpolation and normal script editing keys keep their original behavior.
Suggestions include configured CSV variable names and user-defined variables at
test-plan level and in the current thread group, plus extractor outputs, counters,
User Parameters, and literal names in inline JSR223 vars.put() calls. Disabled
elements and other thread groups are excluded.
Names are cached in memory while completing an expression; no test is run and
variable values are never shown. CSV columns need explicit Variable Names; names
computed dynamically by scripts or read from CSV headers are not inferred.
Script discovery skips comments and quoted examples and never executes code;
referenced script files are not scanned.
For extractors that return all matches, _n inserts _1 with the index selected
for editing. Available suffixes depend on the extractor, including _matchNr,
regular-expression _rand and capture groups, and JSON _ALL when configured.
JSON and JMESPath match-all modes omit the bare reference name because it is only a fallback,
not an extracted match. Names defined independently (for example by CSV) remain available.
Built-in functions appear only after ${_. Functions with arguments insert
parentheses with the caret inside. See the
JMeter function reference
for argument syntax and escaping.
Generated distribution documentation is included under docs/ in release
archives and starts at docs/index.html.
Developer notes:
BreakTest inherits JMeter's trusted-test-plan model. Treat JMX files as executable input: they can define scripts, load classes, call functions, read files, make network requests, and interact with systems reachable from the test runner.
Only open or run test plans you trust, or isolate them first. Report suspected BreakTest vulnerabilities privately as described in SECURITY.md. If an issue also affects upstream Apache JMeter, follow the Apache Software Foundation security process as well.
BreakTest was forked from Apache JMeter:
BreakTest is independent from The Apache Software Foundation. It is not affiliated with, endorsed by, or sponsored by The Apache Software Foundation.
Apache, Apache JMeter, JMeter, the Apache feather, and the Apache JMeter logo are trademarks or registered trademarks of The Apache Software Foundation. BreakTest uses those marks only to describe the origin of the fork and compatibility with Apache JMeter.
BreakTest Community is licensed under the Apache License, Version 2.0. You may use, modify, redistribute, and host Community, including commercially, subject to the license's terms. The license does not grant trademark rights except as described in Section 6.
BreakTest Enterprise is a separate product licensed under a commercial
agreement with Breaking IT. Its proprietary components are not covered by
this repository's Apache-2.0 license. Enterprise licensing requests may be
sent to info@breakingit.nl.
BreakTest is a derivative work of Apache JMeter. Copyright and attribution notices for Apache JMeter and other third-party components are retained in the source tree and distribution notices. Those third-party materials, including Apache JMeter code, remain governed by their own licenses, including the Apache License, Version 2.0.
For legal and licensing information, see:
This distribution may include software that has been designed for use with cryptographic software. The country in which you reside may have restrictions on the import, possession, use, or re-export of encryption software. Before using encryption software, check your country's laws, regulations, and policies.
BreakTest interfaces with the Java Secure Socket Extension (JSSE) API to provide HTTPS support.
BreakTest interfaces, via Apache HttpClient, with the Java Cryptography Extension (JCE) API to provide authentication features such as NTLM.
BreakTest does not include an implementation of JSSE or JCE.
BreakTest exists because Apache JMeter established a useful, open model for performance testing. Thank you to the Apache JMeter community and to everyone testing, reporting, fixing, and modernizing BreakTest from here.