Vayu vs Apache JMeter - a native HTTP load tester without the JVM¶
Apache JMeter has been the default open source load tester for two decades, and that longevity cuts both ways. It tests almost every protocol an enterprise runs, and it does so through a Java Swing interface and a thread-per-user model that has to be tuned, heap-sized, and usually run headless to get honest numbers. Vayu covers the HTTP case with a native C++ engine, from the same app you build the request in.
| Vayu | Apache JMeter | |
|---|---|---|
| Execution engine | C++ (native) | Java (JVM) |
| Concurrency model | Multi-worker event loop | Thread per virtual user |
| API client + load test | Both, one app | Load test only |
| Load test throughput | Tens of thousands of req/s | Moderate (thread-heavy) |
| UI | Native desktop app | Java Swing (dated) |
| Memory usage | Low (direct memory) | High (RAM-intensive) |
| Shareable run summary | One-file HTML report with charts, a Markdown summary and JSON, from the Export menu*** | HTML dashboard report generated from a results file, written as a folder of pages and scripts |
| Protocol breadth | HTTP, GraphQL, SSE | HTTP, JDBC, JMS, FTP, LDAP, SMTP and more |
| Scripting | QuickJS (pm.* syntax) |
Groovy / BeanShell |
| Distributed execution | No - single machine | Yes (controller + workers) |
| MCP / agent control | Built in, local, drives the load engine | No |
| Proxy / custom CA / client certs | In Settings - four proxy modes, additive CAs, per-host certs* | JVM properties and the Java keystore |
| Postman collection import | Yes (v2.0 + v2.1) | No |
| OpenAPI import | Yes (3.1 / 3.0 / 2.0) | No built-in importer (checked 2026-10-23) |
JMeter .jmx import |
Yes - samplers, extractors, assertions, timers and logic controllers, an unmapped class counted rather than dropped** | N/A |
| Open source | Yes (dual-license) | Yes (Apache 2.0) |
* One asterisk that row has earned. system proxy mode resolves a PAC
script once, against a probe URL, applying that one answer engine-wide
rather than per URL; a headless engine with nothing resolved falls back to
environment-variable pickup rather than to no proxy. Client certificates carry
no qualification any more - they are proven on a wire on all three platforms,
in both PEM-pair and PKCS#12 form. Detail:
proxy settings,
TLS trust and
client certificates.
** Common, not complete. JMeter's own class list is open-ended - plugins add more of them - so this is a mapping table, not a JMeter-compatibility claim. HTTP samplers and the JSON/regex/boundary extractors map onto Vayu's element model, and so do:
- Four assertion classes (
ResponseAssertion,DurationAssertion,SizeAssertion,JSONPathAssertion), which become five Vayu assertion kinds because aResponseAssertionon the response code isassert.statusand any other field isassert.contains. - Four timer classes (
ConstantTimer,UniformRandomTimer,GaussianRandomTimer,ConstantThroughputTimer). JMeter ships more, among them the Precise Throughput, Synchronizing and Poisson Random timers and the JSR223 and BeanShell timers, and none of those is mapped. - Five logic controllers (
LoopController,IfController,OnceOnlyController,TransactionController,ThroughputController).SwitchControllerimports as a plain folder, with its members and without acontrol.switch, because JMeter selects by list index or variable value and the plan never declares the named cases that element needs. The other controllers (Simple, While, ForEach, Random, Interleave, Random Order, Runtime, Critical Section, Module, Include) import the same way, their members in source order inside a folder; the looping or selection each one performs in JMeter is not carried, and the import preview counts every controller whose behaviour was lost.
A class this importer has no mapping for (a listener, a cookie manager, a protocol Vayu's HTTP engine does not speak) is counted by its own class name rather than silently dropped. Detail, class by class: the JMeter import doc.
*** What the file leaves out. The report holds aggregates and time series only, never traces, samples or request values, and the HTML page runs no script and loads nothing. Detail: the HTML report.
The engine, and what it does not cost you¶
JMeter's classic constraint is its concurrency model: one thread per virtual
user, on a JVM, which means the load generator's own resource profile becomes
something you tune before you can trust the numbers - heap size, thread ramp,
and the standing advice to run without the GUI because the GUI itself distorts
the result. Vayu's engine is a multi-worker libcurl event loop in C++23, so
concurrency is not threads, and it runs as a sidecar process next to the UI
rather than inside it. That is the architectural reason you can watch a live
dashboard while the run saturates a target: the renderer never shares a thread
with the request load. Measured on a loopback target it reached 56,880 req/s,
matching wrk and edging past vegeta on the same machine -
method and reproduction.
Build the request, then load it¶
In JMeter a test is a tree of samplers, config elements, controllers and
listeners that you assemble before anything is sent, and the request you were
debugging in an API client is rebuilt there by hand. Vayu starts from the other
end: the saved request, with its environment variables, its auth resolved
engine-side, and its pm.* scripts, is what the load run drives. Collections run
as ordered scenarios with per-step results and threshold verdicts, driven from a
CSV, TSV, JSON or JSONL file when you need each virtual user to send different
data. As in JMeter, a failed assertion can fail the run, not just the sample it
ran on: one budget (maxAssertionFailureRatePct) judges the worse of the exact
assert.* population and the sampled pm.test replay, and thresholds.failRun turns a missed
budget into a Failed run. Existing work comes across too - Postman v2.0/v2.1, Insomnia v4 and v5, and
OpenAPI 3.1/3.0 or Swagger 2.0 specs generate a ready-to-use collection. JMeter's
setUp / tearDown thread groups, which run once before or once after the whole
test, are script.setup / script.teardown here - elements on the collection
itself, run once at the run's own start or end in either run mode, rather than
a thread group of their own. Folders carry their own too: a run sets up every
collection above the one it runs, that collection and, with nested
collections included, every folder beneath it, outermost first, and tears
them down in reverse.
When to choose JMeter¶
JMeter is still the right answer for a large class of work, and none of these are things Vayu plans to catch up on:
- You test more than HTTP. JDBC against a database, JMS queues, FTP, LDAP, SMTP, TCP - JMeter's sampler catalogue and plugin ecosystem covers protocols Vayu's HTTP engine does not speak at all.
- You need distributed load. JMeter's controller-and-workers model drives a test from many machines. Vayu runs from one.
- Your
.jmxplans lean on what the importer does not map - a protocol other than HTTP, distributed execution, a plugin sampler, the looping or selection of aSwitchController, While, ForEach, Random or Interleave controller (the members import, the logic does not), or a JSR223/BeanShell script (imported disabled, since Groovy and BeanShell are not JavaScript). A plan built from the common element set (HTTP samplers, the extractors, assertions, timers and the five translated logic controllers in the table above) imports and runs; a team fluent in JMeter's full plugin ecosystem is still better served staying there. - Your load model needs a load-run logic jump. Think time and pacing
timers work under load now (
timer.think, including a gaussian option, on every virtual-user mode; a constant-rate run sends on a schedule and skips it with a warning;timer.pacing, including its shared-cadence case,perUser: false- one cadence held across every virtual user, not one per user; andtimer.throughput, the analogue of JMeter's Constant Throughput Timer, which targets a rate - N per minute - shared across every virtual user by default rather than held per user), and logic controllers - conditionals, once-only, throughput, loops and named transactions - are elements (control.if/.once/.switch/.throughput/.loop/.transaction) that run under load too:control.switch's dispatch andcontrol.loop's repeat jump a scenario load run's virtual users the same way they jump the sequential run,control.throughputcan share one budget across every virtual user (perUser: false) instead of one per user, andcontrol.transactioncan fold a between-membertimer.*wait into its own reported latency (includeTimers). Correlation across a scenario's steps - a login's token reaching the next step's header, per virtual user, kept across that user's iterations while its cookies reset - does work under load now too, provided the extracting element or script runs inline: mark itinline(or set the run'selements.scriptsoverride). A script left in the post-run replay cannot correlate: the replay runs after the load, so the next step is sent with the variable still unresolved. - It has to be JVM-native for your infrastructure, monitoring, or compliance reasons.
Try it¶
Windows:
macOS and Linux: