Built on Java 21's revolutionary virtual threads, VajraPulse delivers 10,000+ TPS with minimal memory footprint. Outperform traditional tools like JMeter, Gatling, and BlazeMeter with a modern, developer-friendly API.
@VirtualThreads
public class HttpLoadTest implements Task {
private HttpClient client;
@Override
public void setup() {
client = HttpClient.newBuilder()
.executor(Executors.newVirtualThreadPerTaskExecutor())
.build();
}
@Override
public TaskResult execute() {
var response = client.send(request, ...);
return TaskResult.success(response.body());
}
}The next-generation load testing tool built for modern applications
Leverage Java 21's Project Loom virtual threads for millions of concurrent operations. Achieve 10,000+ TPS with just ~200MB memory - a fraction of what traditional tools require.
Built exclusively for Java 21+ with records, sealed types, pattern matching, and virtual threads. No legacy baggage, just modern, efficient code.
OpenTelemetry integration for real-time metrics and distributed tracing. Export to Grafana, Prometheus, Jaeger, or any OTEL-compatible backend.
Simple Task interface - just implement setup(), execute(), and cleanup(). No complex configuration files or XML. Pure Java code.
Six built-in patterns plus adaptive load testing. Model any real-world scenario with warm-up/cool-down phases for accurate measurements.
Comprehensive test coverage (โฅ90%), battle-tested patterns, and production-grade reliability. Ready for enterprise workloads.
See why VajraPulse outperforms traditional load testing tools
| Feature |
VajraPulse
Next-Gen
|
JMeter | Gatling | BlazeMeter |
|---|---|---|---|---|
| Architecture | โ Java 21 Virtual Threads | โ Traditional Thread Pool | โ ๏ธ Scala/Akka (Complex) | โ Cloud-based (Vendor Lock-in) |
| Concurrency Model | โ Millions of Virtual Threads | โ Limited by OS Threads | โ ๏ธ Actor Model (Overhead) | โ Limited by Infrastructure |
| Memory Efficiency | โ ~200MB for 100K requests | โ High memory usage | โ ๏ธ Moderate memory usage | โ Cloud costs scale with usage |
| Performance (TPS) | โ 10,000+ TPS per worker | โ ~1,000-2,000 TPS | โ ๏ธ ~3,000-5,000 TPS | โ Varies by plan |
| API Complexity | โ Simple 3-method interface | โ XML configuration | โ ๏ธ DSL learning curve | โ Web UI only |
| Dependencies | โ Zero-dependency API | โ Heavy dependencies | โ ๏ธ Scala ecosystem | โ Cloud service |
| Real-Time Metrics | โ OpenTelemetry native | โ ๏ธ Plugins required | โ ๏ธ Limited integration | โ Built-in (Paid) |
| Adaptive Load Testing | โ Built-in adaptive patterns | โ Manual configuration | โ Not available | โ ๏ธ Limited support |
| Warm-up/Cool-down | โ Native support | โ Manual scripting | โ ๏ธ Complex setup | โ Not available |
| Cost | โ Free & Open Source | โ Free (Apache 2.0) | โ Free (Apache 2.0) | โ Paid service |
| Modern Java Features | โ Records, Sealed Types, Pattern Matching | โ ๏ธ Java 8+ compatible | โ Scala-based | โ N/A |
5-10x better TPS than traditional tools with minimal resource usage
Built for Java 21+ with cutting-edge virtual threads technology
Simplest API in the industry - get started in minutes, not hours
Everything you need for modern load testing
Leverage Java 21's Project Loom for millions of concurrent operations with minimal memory overhead. Perfect for I/O-bound load tests.
Six built-in patterns: Static, Ramp-up, Ramp-sustain, Step, Spike, and Sine wave. Plus adaptive load patterns that adjust based on system response.
OpenTelemetry integration with live metrics during execution. Export to Grafana, Prometheus, Jaeger, or any OTEL-compatible backend.
Just implement the Task interface with setup(), execute(), and cleanup(). The framework handles the rest. No XML, no complex configuration.
Choose virtual threads for I/O-bound tasks or platform threads for CPU-intensive workloads. Annotate and go - @VirtualThreads or @PlatformThreads.
Intelligent load patterns that automatically adjust based on system response. Find optimal performance thresholds automatically.
Built-in support for warm-up and cool-down phases. Metrics are only recorded during steady-state for accurate measurements.
Core API has zero dependencies. Full framework weighs in at just ~1.6MB. Every dependency is justified and minimal.
Comprehensive test coverage (โฅ90%), OpenTelemetry integration, and battle-tested patterns. Ready for production workloads.
Our vision for revolutionizing application performance testing
Our Commitment: VajraPulse is committed to continuous innovation. We're building the future of load testing, one feature at a time. Join us on this journey!
See how easy it is to get started
import com.vajrapulse.api.*;
@VirtualThreads // Use virtual threads for I/O
public class HttpLoadTest implements Task {
private HttpClient client;
private HttpRequest request;
@Override
public void setup() throws Exception {
client = HttpClient.newBuilder()
.executor(Executors.newVirtualThreadPerTaskExecutor())
.connectTimeout(Duration.ofSeconds(10))
.build();
request = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/endpoint"))
.timeout(Duration.ofSeconds(10))
.GET()
.build();
}
@Override
public TaskResult execute() throws Exception {
HttpResponse response = client.send(
request,
HttpResponse.BodyHandlers.ofString()
);
if (response.statusCode() == 200) {
return TaskResult.success(response.body());
} else {
return TaskResult.failure(
new RuntimeException("HTTP " + response.statusCode())
);
}
}
@Override
public void cleanup() throws Exception {
// Cleanup resources if needed
}
} import com.vajrapulse.api.*;
import java.time.Duration;
// Static: Constant TPS
LoadPattern staticPattern = new StaticLoad(
100.0,
Duration.ofMinutes(5)
);
// Ramp-up: Linear increase from 0 to max
LoadPattern rampPattern = new RampUpLoad(
500.0,
Duration.ofSeconds(30)
);
// Ramp-sustain: Ramp then maintain
LoadPattern rampSustain = new RampUpToMaxLoad(
500.0,
Duration.ofSeconds(30), // ramp duration
Duration.ofMinutes(5) // total duration
);
// Step: Discrete phases
LoadPattern stepPattern = new StepLoad(List.of(
new StepLoad.Step(50.0, Duration.ofSeconds(30)),
new StepLoad.Step(200.0, Duration.ofMinutes(1)),
new StepLoad.Step(500.0, Duration.ofMinutes(2))
));
// Sine: Smooth oscillation
LoadPattern sinePattern = new SineWaveLoad(
300.0, // mean rate
150.0, // amplitude
Duration.ofMinutes(3), // total duration
Duration.ofSeconds(20) // period
);
// Spike: Periodic bursts
LoadPattern spikePattern = new SpikeLoad(
200.0, // base rate
800.0, // spike rate
Duration.ofMinutes(2), // total duration
Duration.ofSeconds(15), // spike interval
Duration.ofSeconds(3) // spike duration
);
// With Warm-up and Cool-down
LoadPattern pattern = new WarmupCooldownLoadPattern(
basePattern,
Duration.ofSeconds(30), // Warm-up
Duration.ofSeconds(10) // Cool-down
);import com.vajrapulse.api.*;
// Adaptive load pattern that adjusts based on system response
LoadPattern adaptivePattern = new AdaptiveLoadPattern.Builder()
.initialTps(50.0)
.maxTps(1000.0)
.minTps(10.0)
.rampUpDuration(Duration.ofMinutes(2))
.steadyStateDuration(Duration.ofMinutes(10))
.rampDownDuration(Duration.ofMinutes(1))
.targetLatency(Duration.ofMillis(200))
.maxLatency(Duration.ofMillis(1000))
.targetErrorRate(0.01) // 1% error rate
.maxErrorRate(0.05) // 5% max error rate
.adjustmentInterval(Duration.ofSeconds(10))
.build();
// The pattern automatically:
// - Increases TPS when system performs well
// - Decreases TPS when latency/errors exceed thresholds
// - Finds optimal performance point
// - Provides detailed phase informationimport com.vajrapulse.api.*;
import com.vajrapulse.exporter.console.ConsoleMetricsExporter;
import com.vajrapulse.worker.pipeline.MetricsPipeline;
import java.time.Duration;
public class LoadTestRunner {
public static void main(String[] args) throws Exception {
// Create your task
HttpLoadTest task = new HttpLoadTest();
// Define load pattern
LoadPattern pattern = new StaticLoad(
100.0,
Duration.ofSeconds(30)
);
// Build metrics pipeline with exporters
try (MetricsPipeline pipeline = MetricsPipeline.builder()
.addExporter(new ConsoleMetricsExporter())
.withPeriodic(Duration.ofSeconds(5)) // Live updates
.withPercentiles(0.5, 0.95, 0.99)
.build()) {
// Run the test
pipeline.run(task, pattern);
}
// Automatic cleanup
}
}Add VajraPulse to your project in minutes
dependencies {
// Import BOM
implementation(platform("com.vajrapulse:vajrapulse-bom:0.9.11"))
// Use modules without versions
implementation("com.vajrapulse:vajrapulse-core")
implementation("com.vajrapulse:vajrapulse-worker")
// Optional exporters
implementation("com.vajrapulse:vajrapulse-exporter-console")
implementation("com.vajrapulse:vajrapulse-exporter-opentelemetry")
}dependencies {
// Import BOM
implementation platform('com.vajrapulse:vajrapulse-bom:0.9.11')
// Use modules without versions
implementation 'com.vajrapulse:vajrapulse-core'
implementation 'com.vajrapulse:vajrapulse-worker'
// Optional exporters
implementation 'com.vajrapulse:vajrapulse-exporter-console'
implementation 'com.vajrapulse:vajrapulse-exporter-opentelemetry'
}<dependencyManagement>
<dependencies>
<!-- Import BOM -->
<dependency>
<groupId>com.vajrapulse</groupId>
<artifactId>vajrapulse-bom</artifactId>
<version>0.9.11</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- Use modules without versions -->
<dependency>
<groupId>com.vajrapulse</groupId>
<artifactId>vajrapulse-core</artifactId>
</dependency>
<dependency>
<groupId>com.vajrapulse</groupId>
<artifactId>vajrapulse-worker</artifactId>
</dependency>
</dependencies>Real numbers that speak for themselves
VajraPulse is completely open source and free to use. Released under the Apache License 2.0, you can use it in commercial and personal projects without restrictions.
Permissive open source license that allows you to:
VajraPulse is built by the community, for the community. Contributions are welcome!