High-fidelity API traffic simulation from your IDE.

Gopher-Glide (gg) is an open-source, high-fidelity API traffic simulator. Move beyond brute-force load testing with native IDE integration, zero-config profiles, and an interactive TUI that lets you inject chaos in real-time.

Get Started View on GitHub

The Hive Engine 🐝

A modern architecture for massive scale. Unlike older tools relying on heavy OS threads, the new Hive Engine uses a pure-Go lock-free Actor Model.

By isolating connections into ultra-lightweight Goroutines, a single instance can easily generate over 50,000 RPS with zero-garbage (0 allocs/op) overhead.

graph TD
    Queen[👑 The Queen] -->|Micro-batches| Hatchery[🥚 The Hatchery]
    Hatchery --> Actor1[🐝 Actor Goroutine]
    Hatchery --> Actor2[🐝 Actor Goroutine]
    Actor1 -. API Request .-> API
    Actor2 -. API Request .-> API

⚔️ Resource Benchmark: At 10,000 RPS, gg consumes 4.2x less RAM and 26% less CPU time than Grafana k6, while suffering 3x fewer OS context switches. Read the full benchmark breakdown to see how gg safely simulates massive traffic inside resource-constrained CI/CD pipelines.

Whether you are running on a high-end developer workstation, a standard laptop, or a virtualized cloud runner, the engine scales linearly to extract maximum value from your hardware. Check out the full Performance Benchmarks to see the cross-platform scaling data.

Zero Scripting Required

Reuse your existing .http REST Client files directly. If you want to run a quick load test, there is no need to rewrite your API calls in JavaScript or Python. Just point gg at your existing IDE scratch files and go.

### Simulated User Journey
POST http://api.example.com/login
Content-Type: application/json

{ "user": "tester", "pass": "secure" }

> {%
    client.global.set(
        "token", response.body.token
    );
%}

### Fetch user profile using token
GET http://api.example.com/profile
Authorization: Bearer {{token}}

Zero-Config Profiles

Skip writing complex YAML configs. Use built-in patterns like --profile flash-sale or --profile ddos to generate standard industry traffic shapes instantly.

Perfect for quick validation or CI/CD pipelines where you don't want to maintain external configuration files.

$ gg --hive-engine \
    --http-file checkout.http \
    --profile flash-sale

[Stages]
1. Ramp Up: 0 -> 1000 RPS (30s)
2. Sustain: 1000 RPS (2m)
3. Cool Down: 1000 -> 0 RPS (30s)

[Status] Running Stage 2 (Sustain)...

Interactive Chaos TUI

Adjust traffic in real-time using the newly polished, premium interactive TUI. Targeting a smooth ~24 FPS, you can bias RPS up or down using your arrow keys, and watch the terminal UI react instantly without stutter or lag—styled beautifully by default with a Catppuccin Macchiato palette.

Combined with the --snap flag, you can record behavioral snapshots of your API's latency, status distributions, and inferred JSON schemas.

Interactive Chaos TUI Demo

Semantic Diffing 🔬

Know why your API broke, not just when. Traditional tools tell you P99 latency spiked. gg snap diff tells you it spiked because a developer accidentally injected a 2MB blob into the JSON payload.

By continuously sampling traffic, Gopher-Glide infers your API's schema in real-time. Compare two snapshots side-by-side to instantly spot missing fields, type changes, or massive payload bloat.

GET:http://localhost:8080/fast-get  [❌ REGRESSION]

Latency Deltas      Payload Deltas      Error & Status
 P50:    +100.0%     Avg:    +100.0%     Error: -100.00 pp
 P95:    +100.0%     P95:    +100.0%
 P99:   +5200.0%     Max:    +100.0%     200:   +100.0 pp
 Max:    +785.7%

Schema Changes
 + active          added  boolean  100% STABLE
 + email           added  string   100% STABLE
 + metadata        added  object    18% RARE
 + metadata.source added  string    18% RARE

Automated CI/CD Gates 🚦

Don't let regressions reach production. Gopher-Glide is built for more than just local chaos testing. Drop it directly into your CI/CD pipelines to enforce hard limits on performance and payload shapes.

Use gg snap assert to automatically break the build if a Pull Request spikes P99 latency by 10% or removes a critical field from your JSON schema.

jobs:
  api-regression:
    runs-on: ubuntu-latest
    container: shyam-s00/gopher-glide:latest
    steps:
      - name: Run API Simulator
        run: |
          gg --hive-engine \
            --http-file api.http \
            --snap --snap-tag ${{ github.sha }} \
            --headless

      - name: Enforce API Contracts
        run: |
          gg snap assert \
            --baseline main \
            --current ${{ github.sha }} \
            --latency-regression 10 \
            --deny-removed-fields

Why Gopher-Glide?

If you want to run a quick concurrency test, you usually have to write a custom script or learn a heavy configuration language. gg lets you skip the boilerplate.

Feature	Gopher-Glide (`gg`)	k6 / Locust	wrk / hey / vegeta
Scripting	None (Reads `.http` natively)	JavaScript / Python	None (CLI flags only)
Traffic Control	30-FPS Interactive TUI (Arrow keys)	Requires configs	Fixed concurrency only
CI/CD Assertions	Semantic JSON Diffing (`gg snap`)	Pass/Fail Thresholds	Raw latencies only
Built-in Profiles	Yes (`--profile flash-sale`)	Requires scripting	No
IDE Integration	Native JetBrains Plugin	External scripts	External tools
Performance	30k+ RPS per core (Actor Model)	Medium-High	Extremely High

Get started in minutes

No scripting language to learn, no config files to maintain — reuse what's already in your IDE.

01

Install

Get the binary via Homebrew, or grab a prebuilt release for Linux/Windows.

brew install shyam-s00/tap/gg

02

Write a Journey

Reuse your existing .http files. Chain requests into a stateful Journey by exporting a value with @gg-export and referencing it as {{token}} in the next request.

### Login
# @gg-export token = jsonpath: $.data.token
POST http://api.example.com/login
Content-Type: application/json

{ "user": "tester", "pass": "secure" }

### Fetch profile
GET http://api.example.com/profile
Authorization: Bearer {{token}}

03

Pick a Profile

Skip the YAML — choose a built-in traffic shape that matches your scenario.

gg --hive-engine \
  --http-file checkout.http \
  --profile flash-sale

04

Simulate & Watch

Drop into the interactive TUI, bias load up or down with the arrow keys, and capture --snap snapshots as you go.

[Stages]
1. Ramp Up: 0 -> 1000 RPS (30s)
2. Sustain: 1000 RPS (2m)
3. Cool Down: 1000 -> 0 RPS (30s)

[Status] Running Stage 2 (Sustain)...

Frequently Asked Questions

Everything you need to know about Gopher-Glide.

What is an API traffic simulator?

Unlike traditional API load testing tools that blindly spam endpoints, a traffic simulator like Gopher-Glide creates stateful, multi-step user journeys. It mimics human think-time and realistic behaviors, giving you high-fidelity insights into how your backend actually performs under real-world pressure.

Is Gopher-Glide a k6 or JMeter alternative?

Yes. If you are looking for a modern, open-source alternative to k6, JMeter, or Locust, Gopher-Glide offers a zero-code approach. Instead of writing complex JavaScript or Python scripts, you reuse your existing .http REST Client files directly from your IDE.

How much load can a single instance generate?

Thanks to the new pure-Go lock-free Hive Engine, a single Gopher-Glide instance can comfortably push over 50,000 RPS (Requests Per Second) on modern hardware without exhausting system memory or triggering garbage collection pauses.

Can I run this in my CI/CD pipeline?

Absolutely. You can use our official Docker image (docker pull shyam-s00/gopher-glide) to easily drop it into any CI/CD workflow like GitHub Actions or GitLab CI. By passing the --headless flag, Gopher-Glide outputs structured data instead of the UI. You can even use gg snap assert to create automated regression gates that break the build if API latency spikes.