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. While older tools rely on heavy OS threads or memory-intensive Virtual Machines, the newly released Hive Engine (v0.9.0) flips the paradigm with a pure-Go Actor Model.

By isolating each concurrent connection into an ultra-lightweight Goroutine and utilizing lock-free message passing, Gopher-Glide bypasses traditional memory and scheduling bottlenecks. A single instance can easily generate over 50,000 RPS on a standard multi-core machine with a proven zero-garbage (0 allocs/op) metrics subsystem.

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.

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

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 interactive TUI. Bias RPS up or down using your arrow keys, and watch the beautiful terminal UI react instantly.

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	Live 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

Three steps. Zero config.

01

Install

Get the binary via Homebrew in seconds.

brew install shyam-s00/tap/gg

02

Write

Use your existing IDE `.http` files.

GET http://localhost:8080/health

03

Simulate

Run the traffic simulator with a built-in profile.

gg --hive-engine \ --http-file api.http \ --profile 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.