kaioken

December 30, 2025 · View on GitHub

A Rust-based HTTP load testing tool with real-time terminal UI and DBZ flavor.

Features

Real-time TUI - Live metrics with latency percentiles, RPS, status codes
Constant arrival rate - Fixed RPS load generation with automatic VU scaling
Latency correction - Avoid coordinated omission for accurate percentiles
Thresholds - CI/CD pass/fail criteria (p95 < 500ms, error_rate < 0.01, check_pass_rate > 0.95)
Checks - Response validation (status codes, body content, regex) with pass rate tracking
Request chaining - Extract values from responses for subsequent requests
Stages - Multi-phase load profiles (ramp up → hold → ramp down)
Weighted scenarios - Multi-endpoint testing with traffic distribution and tags
Cookie jar - Automatic session handling across requests
Rate limiting - Token bucket algorithm for controlled load
Ramp-up & warmup - Gradual worker activation and connection priming
Compare mode - Regression detection with CI-friendly exit codes
Multiple outputs - JSON, CSV, Markdown, and HTML reports
Variable interpolation - Dynamic ${REQUEST_ID}, ${TIMESTAMP_MS}, and extracted values
HTTP/2 support - Optional h2 prior knowledge mode
Proxy support - HTTP, HTTPS, and SOCKS5 proxies
Basic auth - Simple user:password authentication
Multipart forms - File uploads with curl-like -F syntax
Client certificates - mTLS authentication for enterprise APIs
Debug mode - Single request with full request/response dump
Random regex URLs - Generate dynamic URLs from regex patterns
Burst mode - Spike testing with N requests, delay, repeat
SQLite logging - Export snapshots to SQLite for analysis
DNS override - Route requests to different hosts (--connect-to)
Prometheus export - Real-time metrics for Grafana dashboards
DBZ themes - 6 color schemes (press t to cycle)

vs Other Tools

Feature	kaioken	k6	oha	wrk	Gatling
Real-time TUI	✅	❌	✅	❌	❌
Zero config	✅	❌	✅	✅	❌
Compare mode	✅	❌	❌	❌	❌
Latency correction	✅	❌	✅	❌	❌
HTML reports	✅	✅	❌	❌	✅
Checks/thresholds	✅	✅	❌	❌	✅
Stages	✅	✅	❌	❌	✅
Arrival rate	✅	✅	❌	❌	✅
Request chaining	✅	✅	❌	❌	✅
Weighted scenarios	✅	✅	❌	❌	✅
Cookie jar	✅	✅	❌	❌	✅
HTTP/2	✅	✅	✅	❌	✅
HTTP/3	✅*	❌	✅	❌	❌
WebSocket	✅	✅	❌	❌	✅
gRPC	✅*	✅	❌	❌	✅
Proxy	✅	✅	✅	❌	✅
Basic auth	✅	✅	✅	❌	✅
Multipart upload	✅	✅	✅	❌	✅
Client certs (mTLS)	✅	✅	✅	❌	✅
Random regex URLs	✅	❌	✅	❌	❌
Burst mode	✅	❌	❌	❌	❌
SQLite logging	✅	❌	✅	❌	❌
Prometheus export	✅	✅	❌	❌	✅
Config file	TOML	JS	❌	Lua	Scala
Language	Rust	Go	Rust	C	Scala

* Experimental feature

kaioken strengths: Real-time visibility, regression detection, CI/CD thresholds, load stages, request chaining, latency correction, memorable UX

Installation

Pre-built binaries (recommended)

Download from GitHub Releases:

# Linux x86_64
curl -LO https://github.com/lance0/kaioken/releases/latest/download/kaioken-linux-x86_64.tar.gz
tar xzf kaioken-linux-x86_64.tar.gz
sudo mv kaioken /usr/local/bin/

# macOS (Apple Silicon)
curl -LO https://github.com/lance0/kaioken/releases/latest/download/kaioken-macos-aarch64.tar.gz
tar xzf kaioken-macos-aarch64.tar.gz
sudo mv kaioken /usr/local/bin/

# macOS (Intel)
curl -LO https://github.com/lance0/kaioken/releases/latest/download/kaioken-macos-x86_64.tar.gz
tar xzf kaioken-macos-x86_64.tar.gz
sudo mv kaioken /usr/local/bin/

Homebrew (macOS/Linux)

brew tap lance0/kaioken
brew install kaioken

Cargo (from source)

cargo install kaioken

# With HTTP/3 support (experimental)
cargo install kaioken --features http3

# With gRPC support (experimental)
cargo install kaioken --features grpc

# With all features
cargo install kaioken --features "http3 grpc"

Quick Start

# Basic test
kaioken run https://api.example.com/health

# With options
kaioken run https://api.example.com/users \
  -c 100 -d 30s -r 500 --warmup 5s

# Fixed number of requests
kaioken run https://api.example.com -n 10000

# Generate starter config
kaioken init --url https://api.example.com

# Validate config without running
kaioken run -f config.toml --dry-run

# Compare two runs for regressions
kaioken compare baseline.json current.json

# Shell completions
kaioken completions bash >> ~/.bashrc

5-Minute Tutorial

This tutorial walks you through testing an API endpoint, from basic test to CI/CD integration.

Step 1: Run Your First Test

# Test an endpoint with 50 concurrent users for 10 seconds
kaioken run https://httpbin.org/get

You'll see a real-time TUI showing requests/sec, latency percentiles, and status codes. Press q to quit early or wait for completion.

Step 3: Add Response Validation

Ensure your API returns correct responses:

[[checks]]
name = "status is 200"
status = 200

[[checks]]
name = "response has users"
body_contains = "users"

[[checks]]
name = "response time OK"
max_latency = "500ms"

The TUI shows check pass rates in real-time.

Step 4: Set CI/CD Thresholds

Fail the test if performance degrades:

[thresholds]
p95_latency = "< 500ms"     # 95th percentile under 500ms
p99_latency = "< 1s"        # 99th percentile under 1s
error_rate = "< 0.01"       # Less than 1% errors
check_pass_rate = "> 0.95"  # 95% of checks pass
rps = "> 100"               # At least 100 req/s

Exit code is non-zero if thresholds are breached.

Step 5: Compare Results for Regressions

Save results and compare against baselines:

# Save baseline
kaioken run -f api-test.toml -o baseline.json

# After code changes, compare
kaioken run -f api-test.toml -o current.json
kaioken compare baseline.json current.json

compare exits with code 3 if regressions detected—perfect for CI gates.

Step 6: Run in CI/CD

# .github/workflows/load-test.yml
- name: Load test
  run: |
    kaioken run -f api-test.toml -o results.json --no-tui
    kaioken compare baseline.json results.json
  env:
    API_TOKEN: ${{ secrets.API_TOKEN }}

What's Next?

Arrival rate mode: Fixed RPS with --arrival-rate 100
Stages: Ramp up/down with [[stages]]
Request chaining: Extract tokens with [extraction]
Weighted scenarios: Multi-endpoint with [[scenarios]]

See the examples/ folder for complete configurations.

TUI Preview

kaioken TUI

Press t to cycle themes: Earth → Namek → Planet Vegeta → Time Chamber → Tournament → Frieza Force

CLI Reference

`kaioken run`

kaioken run [OPTIONS] [URL]

Flag	Default	Description
`[URL]`	—	Target URL (required unless using `-f`)
`-c, --concurrency`	50	Concurrent workers
`-d, --duration`	10s	Test duration
`-n, --max-requests`	0	Stop after N requests (0 = unlimited, supports k/m suffixes)
`-r, --rate`	0	Max RPS (0 = unlimited)
`--ramp-up`	0s	Time to reach full concurrency
`--warmup`	0s	Warmup period (not measured)
`--think-time`	—	Pause between requests (e.g., 500ms)
`--arrival-rate`	0	Target RPS (enables arrival rate mode)
`--max-vus`	100	Max VUs for arrival rate mode
`--no-latency-correction`	false	Disable latency correction
`--no-follow-redirects`	false	Don't follow HTTP redirects
`-m, --method`	GET	HTTP method
`-H, --header`	—	Header (repeatable)
`-b, --body`	—	Request body
`--body-file`	—	Load body from file
`--http2`	false	Use HTTP/2 prior knowledge
`--cookie-jar`	false	Enable cookie jar for session handling
`-f, --config`	—	TOML config file
`-o, --output`	—	Output file path
`--format`	json	Output format: json, csv, md, html
`--no-tui`	false	Headless mode
`--json`	false	Shorthand for `--no-tui --format json`
`--dry-run`	false	Validate config and exit
`--debug`	false	Send single request, print full dump
`--fail-fast`	false	Abort immediately on threshold breach
`--serious`	false	Disable DBZ flavor
`--insecure`	false	Skip TLS verification
`--disable-keepalive`	false	Disable connection reuse
`-y, --yes`	false	Skip remote target confirmation
`-x, --proxy`	—	Proxy URL (http/https/socks5)
`-a, --basic-auth`	—	Basic auth credentials (user:pass)
`-F, --form`	—	Multipart form field (repeatable)
`--cert`	—	Client certificate (PEM) for mTLS
`--key`	—	Client private key (PEM) for mTLS
`--cacert`	—	CA certificate (PEM) for custom CA
`--rand-regex-url`	—	Generate URLs from regex pattern
`--urls-from-file`	—	Read URLs from file (round-robin)
`-Z, --body-lines`	—	Body lines from file (round-robin)
`--connect-to`	—	DNS override (HOST:TARGET_IP:TARGET_PORT)
`--db-url`	—	SQLite database for snapshot logging
`--burst-rate`	—	Requests per burst (enables burst mode)
`--burst-delay`	—	Delay between bursts (e.g., 1s)
`--prometheus-pushgateway`	—	Push metrics to Prometheus Pushgateway URL
`--prometheus-port`	—	Expose /metrics endpoint on this port
`--http3`	false	Use HTTP/3 (QUIC) - experimental
`--grpc-service`	—	gRPC service name (experimental)
`--grpc-method`	—	gRPC method name (experimental)

`kaioken compare`

kaioken compare <BASELINE> <CURRENT> [OPTIONS]

Compare two JSON result files for regressions. Prints load model metadata and validates compatibility.

Flag	Default	Description
`--threshold-p99`	10.0	p99 latency regression threshold (%)
`--threshold-p999`	15.0	p999 latency regression threshold (%)
`--threshold-error-rate`	50.0	Error rate regression threshold (%)
`--threshold-rps`	10.0	RPS regression threshold (%)
`--force`	false	Allow comparing different load models (open vs closed)
`--json`	false	Output as JSON

Exit codes: 0 (success), 3 (regressions), 5 (load model mismatch without --force)

`kaioken init`

kaioken init [OPTIONS]

Generate a starter config file with documented options.

Flag	Default	Description
`-o, --output`	kaioken.toml	Output file path
`-u, --url`	—	Target URL to include
`--force`	false	Overwrite existing file

`kaioken completions`

kaioken completions <SHELL>

Generate shell completions. Supported: bash, zsh, fish, powershell, elvish.

`kaioken import`

kaioken import <FILE> [OPTIONS]

Convert HAR (HTTP Archive) files from browser DevTools to kaioken config.

Flag	Default	Description
`<FILE>`	—	HAR file to import
`-o, --output`	kaioken.toml	Output file path
`--filter`	—	URL regex filter (e.g., "api/v2")

# Import from Chrome DevTools HAR export
kaioken import recording.har -o load-test.toml

# Filter by URL pattern
kaioken import api.har --filter "api/v2" -o filtered.toml

The importer:

Auto-detects format from file extension
Preserves headers, body, and method from HAR entries
Creates weighted scenarios from duplicate requests
Filters browser-specific headers (cookies, sec-*, etc.)

Config File

[target]
url = "https://api.example.com/users"
method = "POST"
timeout = "5s"
connect_timeout = "2s"
# http2 = false
# insecure = false
# cookie_jar = false  # Enable for session handling
# follow_redirects = true  # Set false to not follow redirects
# disable_keepalive = false  # Disable connection reuse

# Authentication & security
# proxy = "http://proxy:8080"  # HTTP/HTTPS/SOCKS5 proxy
# basic_auth = "user:password"  # Basic authentication
# cert = "/path/to/client.crt"  # Client certificate (mTLS)
# key = "/path/to/client.key"   # Client private key (mTLS)
# cacert = "/path/to/ca.crt"    # Custom CA certificate

# Multipart form data (alternative to body)
# form_data = ["field=value", "file=@/path/to/upload.txt"]

[target.headers]
Authorization = "Bearer ${API_TOKEN}"
Content-Type = "application/json"

# body = '{"key": "value"}'
# body_file = "payload.json"

[load]
concurrency = 100
duration = "30s"
# max_requests = 0
# rate = 500
# ramp_up = "5s"
# warmup = "3s"
# think_time = "500ms"

# Arrival rate mode (alternative to concurrency)
# arrival_rate = 100  # Fixed 100 RPS
# max_vus = 200       # Cap on concurrent VUs

Environment variables: ${VAR} or ${VAR:-default}

Constant Arrival Rate

Generate load at a fixed RPS regardless of response times. VUs scale automatically.

# CLI: 100 RPS with up to 50 VUs
kaioken run --arrival-rate 100 --max-vus 50 -d 1m https://api.example.com

[load]
arrival_rate = 100  # Target: 100 requests/second
max_vus = 200       # Max concurrent VUs (auto-scales)
duration = "5m"

Ramping Arrival Rate (Stages)

Use target_rate in stages for RPS-based load profiles:

[load]
max_vus = 200

[[stages]]
duration = "1m"
target_rate = 50    # Ramp up to 50 RPS

[[stages]]
duration = "5m"
target_rate = 200   # Ramp to 200 RPS

[[stages]]
duration = "1m"
target_rate = 0     # Ramp down

How it works:

Iterations spawn at the target rate (e.g., 100/sec = one every 10ms)
If responses are slow, more VUs are allocated (up to max_vus)
If all VUs are busy, iterations are dropped and tracked
Dropped iterations indicate the system can't sustain the target rate

vs Rate Limiting (--rate):

--rate limits an existing pool of workers (caps RPS from above)
--arrival-rate maintains a constant RPS (spawns work from below)

Latency Correction

When using arrival rate mode, latency correction is automatically enabled to avoid the coordinated omission problem.

When the server slows down, requests queue waiting for available VUs. Without correction, this queue time inflates latency percentiles. With correction:

Queue time is tracked separately (time waiting for a VU)
Corrected latency = total latency - queue time (actual server response time)
TUI shows [corrected] indicator when active
JSON output includes both corrected_latency_us and queue_time_us

Disable with --no-latency-correction if you want wall-clock latency instead.

Thresholds

Define pass/fail criteria for CI/CD pipelines:

[thresholds]
p95_latency_ms = "< 500"
p99_latency_ms = "< 1000"
error_rate = "< 0.01"
rps = "> 100"
check_pass_rate = "> 0.95"  # 95% of checks must pass

Available metrics:

p50_latency_ms, p75_latency_ms, p90_latency_ms, p95_latency_ms, p99_latency_ms, p999_latency_ms
mean_latency_ms, max_latency_ms
error_rate (0.0 - 1.0)
rps (requests per second)
check_pass_rate (0.0 - 1.0) - percentage of checks passing

Operators: <, <=, >, >=, ==

Exit codes:

0 - Success
1 - Error (high error rate, config issues)
3 - Regressions detected (compare mode)
4 - Thresholds failed
5 - Load model mismatch in compare (without --force)

Checks

Validate response status codes and body content:

[[checks]]
name = "status_ok"
condition = "status == 200"

[[checks]]
name = "success_codes"
condition = "status in [200, 201, 204]"

[[checks]]
name = "has_data"
condition = "body contains \"success\""

[[checks]]
name = "valid_json"
condition = "body matches \"\\{.*\\}\""

Check results are displayed after the test with pass/fail percentages.

Request Chaining

Extract values from responses and use in subsequent requests:

[[scenarios]]
name = "login"
url = "https://api.example.com/auth"
method = "POST"
body = '{"user": "test", "pass": "secret"}'
weight = 0  # weight=0 means dependency only

[scenarios.extract]
token = "json:$.access_token"
session_id = "header:X-Session-Id"

[[scenarios]]
name = "get_profile"
url = "https://api.example.com/me"
method = "GET"
weight = 10

[scenarios.headers]
Authorization = "Bearer ${token}"

Extraction sources:

json:$.path.to.value - JSONPath extraction
regex:pattern:group - Regex capture group
body - Entire response body

Extracted values are available as ${varname} in URLs, headers, and body.

Stages

Define multi-phase load profiles (ramp up, hold, ramp down):

[target]
url = "https://api.example.com/health"

[[stages]]
duration = "30s"
target = 50      # ramp to 50 workers

[[stages]]
duration = "2m"
target = 50      # hold at 50

[[stages]]
duration = "30s"
target = 0       # ramp down to 0

When stages are configured:

Total duration is calculated automatically
Max worker count is determined from highest target
Workers ramp up/down gradually within each stage

Weighted Scenarios

Test multiple endpoints with different traffic ratios:

[load]
concurrency = 100
duration = "60s"

[[scenarios]]
name = "list_users"
url = "https://api.example.com/users"
method = "GET"
weight = 7  # 70% of traffic
tags = { endpoint = "users", version = "v2" }

[[scenarios]]
name = "create_user"
url = "https://api.example.com/users"
method = "POST"
body = '{"name": "test-${REQUEST_ID}"}'
weight = 2  # 20% of traffic
tags = { endpoint = "users", operation = "write" }

[[scenarios]]
name = "health_check"
url = "https://api.example.com/health"
method = "GET"
weight = 1  # 10% of traffic

Tags are optional metadata for organizing and filtering scenarios in output.

Validate with --dry-run:

$ kaioken run -f config.toml --dry-run
Configuration validated successfully!

Scenarios:   3 defined
  - list_users (GET .../users) weight=7 (70%)
  - create_user (POST .../users) weight=2 (20%)
  - health_check (GET .../health) weight=1 (10%)
Concurrency: 100
Duration:    60s

Variable Interpolation

Available in URL, headers, and body:

Variable	Description
`${REQUEST_ID}`	Unique ID per request (worker_id * 1B + counter)
`${TIMESTAMP_MS}`	Current epoch time in milliseconds

Example:

kaioken run 'https://api.example.com/items/${REQUEST_ID}' \
  -H 'X-Request-ID: ${REQUEST_ID}' \
  -b '{"ts": ${TIMESTAMP_MS}}'

WebSocket Testing

Test WebSocket endpoints with echo or fire-and-forget modes:

# Echo mode (default) - measure RTT
kaioken run ws://localhost:8080/ws -c 100 -d 30s -b '{"type":"ping"}'

# Fire-and-forget - measure throughput
kaioken run ws://localhost:8080/events -c 50 --ws-fire-and-forget

TOML config:

[target]
url = "wss://api.example.com/ws"

[websocket]
message_interval = "100ms"
mode = "echo"  # or "fire_and_forget"

Proxy Support

Route requests through HTTP, HTTPS, or SOCKS5 proxies:

# HTTP proxy
kaioken run https://api.example.com -x http://proxy:8080

# SOCKS5 proxy
kaioken run https://api.example.com -x socks5://127.0.0.1:1080

# Authenticated proxy
kaioken run https://api.example.com -x http://user:pass@proxy:8080

TOML config:

[target]
url = "https://api.example.com"
proxy = "http://proxy:8080"

Basic Authentication

Authenticate with username and password:

kaioken run https://api.example.com -a admin:secret

TOML config:

[target]
url = "https://api.example.com"
basic_auth = "admin:secret"

Multipart Form Upload

Upload files and form data using curl-like syntax:

# Text field
kaioken run https://api.example.com -F "name=value"

# File upload
kaioken run https://api.example.com -F "file=@/path/to/upload.txt"

# File with custom filename and MIME type
kaioken run https://api.example.com -F "doc=@report.pdf;filename=final.pdf;type=application/pdf"

# Multiple fields
kaioken run https://api.example.com -m POST \
  -F "user=test" \
  -F "avatar=@photo.jpg"

TOML config:

[target]
url = "https://api.example.com"
method = "POST"
form_data = ["field1=value1", "file=@/path/to/upload.txt"]

Note: --form and --body are mutually exclusive.

Client Certificates (mTLS)

Authenticate with client certificates for mutual TLS:

# Client certificate + key
kaioken run https://secure.example.com --cert client.crt --key client.key

# With custom CA (for self-signed server certs)
kaioken run https://secure.example.com \
  --cert client.crt --key client.key --cacert ca.crt

TOML config:

[target]
url = "https://secure.example.com"
cert = "/path/to/client.crt"
key = "/path/to/client.key"
cacert = "/path/to/ca.crt"  # optional

Note: --cert and --key must be used together. Certificates must be in PEM format.

Debug Mode

Send a single request and print full request/response details before running a load test:

# Simple GET
kaioken run https://api.example.com/health --debug

# POST with headers and body
kaioken run https://api.example.com/users \
  -m POST \
  -H "Content-Type: application/json" \
  -b '{"name":"test"}' \
  --debug

Output shows:

Request: method, URL, headers, body (JSON pretty-printed)
Response: status, latency, headers, body
Errors: with actionable suggestions

Disable Keepalive

Disable HTTP connection reuse to measure connection establishment overhead:

kaioken run https://api.example.com -c 10 -d 30s --disable-keepalive

TOML config:

[target]
url = "https://api.example.com"
disable_keepalive = true

Each request creates a new TCP connection. Useful for measuring TLS handshake and connection overhead.

HTTP/3 (Experimental)

Build with HTTP/3 support and use QUIC transport:

cargo install kaioken --features http3

kaioken run https://quic.example.com --http3

Requires the target server to support HTTP/3.

Limitations: HTTP/3 mode uses simple constant-VU execution. Options like --arrival-rate, --rate, --think-time, --ramp-up, and [[scenarios]] are ignored. Use standard HTTP mode for these features.

gRPC (Experimental)

Build with gRPC support to load test gRPC services:

cargo install kaioken --features grpc

# Unary call with inline body
kaioken run https://localhost:50051 \
  --grpc-service "helloworld.Greeter" \
  --grpc-method "SayHello" \
  -b 'raw protobuf bytes here' \
  -c 50 -d 30s

# Or load binary protobuf from file
kaioken run https://localhost:50051 \
  --grpc-service "helloworld.Greeter" \
  --grpc-method "SayHello" \
  --body-file request.bin \
  -c 50 -d 30s

Supports unary calls and server streaming. The request body should be raw protobuf-encoded bytes. Use --body-file to load binary protobuf data from a file. JSON-to-protobuf conversion is not currently supported.

Limitations: gRPC mode uses simple constant-VU execution. Options like --arrival-rate, --rate, --think-time, --ramp-up, and [[scenarios]] are ignored. The --insecure flag is not supported; use http:// URLs for unencrypted connections.

Prometheus Metrics Export

Export real-time metrics to Prometheus for Grafana dashboards. Two modes available:

Push to Pushgateway

Push metrics every 100ms to a Prometheus Pushgateway:

# Start Pushgateway (Docker)
docker run -d -p 9091:9091 prom/pushgateway

# Run load test with metrics push
kaioken run https://api.example.com -c 50 -d 60s \
  --prometheus-pushgateway http://localhost:9091

# View metrics
curl http://localhost:9091/metrics | grep kaioken

Expose /metrics Endpoint

Serve a Prometheus-compatible HTTP endpoint for scraping:

# Run load test with metrics endpoint
kaioken run https://api.example.com -c 50 -d 60s --prometheus-port 9090

# Scrape metrics (in another terminal)
curl http://localhost:9090/metrics

TOML Config

[load]
# Option 1: Push to Pushgateway
prometheus_pushgateway = "http://localhost:9091"

# Option 2: Expose endpoint (mutually exclusive with pushgateway)
# prometheus_port = 9090

Available Metrics

All metrics are prefixed with kaioken_ and include labels job="kaioken" and instance="<target_url>":

Metric	Type	Description
`kaioken_requests_total`	Counter	Total requests made
`kaioken_requests_success_total`	Counter	Successful requests
`kaioken_requests_failed_total`	Counter	Failed requests
`kaioken_rps`	Gauge	Current requests per second
`kaioken_error_rate`	Gauge	Current error rate (0.0-1.0)
`kaioken_latency_p50_ms`	Gauge	50th percentile latency
`kaioken_latency_p95_ms`	Gauge	95th percentile latency
`kaioken_latency_p99_ms`	Gauge	99th percentile latency
`kaioken_latency_p999_ms`	Gauge	99.9th percentile latency
`kaioken_vus_active`	Gauge	Active virtual users
`kaioken_vus_max`	Gauge	Maximum virtual users
`kaioken_bytes_received_total`	Counter	Total bytes received
`kaioken_dropped_iterations_total`	Counter	Dropped iterations (arrival rate)

Grafana Queries

# RPS over time
kaioken_rps{job="kaioken"}

# P99 latency in milliseconds
kaioken_latency_p99_ms{job="kaioken"}

# Error rate as percentage
kaioken_error_rate{job="kaioken"} * 100

# Active VUs
kaioken_vus_active{job="kaioken"}

# Total requests (counter)
rate(kaioken_requests_total{job="kaioken"}[1m])

CI Integration

# GitHub Actions example with thresholds
- name: Load test with thresholds
  run: |
    cat > test.toml << EOF
    [target]
    url = "https://api.example.com/health"
    
    [load]
    concurrency = 50
    duration = "30s"
    
    [thresholds]
    p95_latency_ms = "< 500"
    error_rate = "< 0.01"
    EOF
    
    kaioken run -f test.toml --no-tui -o results.json -y
    # Exits with code 4 if thresholds fail

- name: Check for regressions (optional)
  run: |
    kaioken compare baseline.json results.json \
      --threshold-p99 15 --threshold-rps 10

Power Levels

RPS	Rank
0-100	Farmer
101-500	Krillin
501-1,000	Piccolo
1,001-5,000	Vegeta
5,001-9,000	Goku
9,001+	OVER 9000

License

Licensed under either of:

Apache License, Version 2.0 (LICENSE-APACHE)
MIT license (LICENSE-MIT)

at your option.