Skip to content
Back to search

pepe

MarketplaceWorks with Claude CodeGitHub

Fast HTTP load testing tool with a live terminal dashboard. Ramp to find capacity, replay access logs, test OpenAPI specs, chain requests, and watch nginx logs live. Written in Rust.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/omarmhaimdat/pepe with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/omarmhaimdat/pepe'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/omarmhaimdat--pepe/badge.svg)](/listings/omarmhaimdat--pepe)

HTML

<a href="/listings/omarmhaimdat--pepe"><img src="/api/listings/omarmhaimdat--pepe/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

curl -LsSf https://pepe.mhaimdat.com/install.sh | sh        # macOS and Linux
brew install omarmhaimdat/pepe/pepe                         # Homebrew
nix run github:omarmhaimdat/pepe -- https://example.com     # Nix, without installing
docker run --rm -it ghcr.io/omarmhaimdat/pepe https://example.com
cargo install --locked --git https://github.com/omarmhaimdat/pepe

Windows, in PowerShell: `powershell -ExecutionPolicy Bypass -c "irm https://pepe.mhaimdat.com/install.ps1 | iex"`. Every [release](https://github.com/omarmhaimdat/pepe/releases) also ships binaries for macOS, Linux and Windows with checksums and signed provenance, the shell completions and the man pages. `pepe self-update` installs the latest release; pepe looks for one once a day and says so when a run ends. All of it, with the details, on the [install page](https://pepe.mhaimdat.com/docs/install.html).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 18 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "pepe",
  3. "owner": {
  4. "name": "Omar Mhaimdat"
  5. },
  6. "metadata": {
  7. "description": "pepe, the HTTP load generator and latency tool, as a Claude Code plugin"
  8. },
  9. "plugins": [
  10. {
  11. "name": "pepe",
  12. "source": "./",
  13. "description": "Find why an HTTP endpoint is slow and prove a fix: latency by phase, load tests, the service's time by operation from its OpenTelemetry spans, before and after compared. A skill and pepe's MCP server under guardrails.",
  14. "category": "developer-tools",
  15. "tags": ["http", "load-testing", "latency", "performance", "opentelemetry", "benchmark", "mcp"]
  16. }
  17. ]
  18. }
README.md · README · 115 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src="assets/logo.svg" width="112" alt="Pepe, a pixel-art chili pepper">
  3. # pepe
  4. **An HTTP load generator with a live dashboard, built to cost less than the server it tests.**
  5. [![CI](https://github.com/omarmhaimdat/pepe/actions/workflows/CI.yaml/badge.svg)](https://github.com/omarmhaimdat/pepe/actions/workflows/CI.yaml) [![Release](https://img.shields.io/github/v/release/omarmhaimdat/pepe?display_name=tag&color=brightgreen)](https://github.com/omarmhaimdat/pepe/releases/latest) [![Downloads](https://img.shields.io/github/downloads/omarmhaimdat/pepe/total?color=blue)](https://github.com/omarmhaimdat/pepe/releases) [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE) ![Rust 1.85+](https://img.shields.io/badge/rust-1.85%2B-orange)
  6. [Install](#install) · [Quick start](#quick-start) · [What it does](#what-it-does) · [Scripts, CI and agents](#scripts-ci-and-agents) · [How it compares](#how-pepe-compares) · [Documentation](https://pepe.mhaimdat.com/docs/) · [Roadmap](ROADMAP.md)
  7. </div>
  8. ![pepe load-testing a server: the live dashboard, the request log, and the verdict](assets/run.gif)
  9. pepe sends requests to a URL, as many at once as you ask, and shows what came back as it happens: throughput, latency percentiles and a heatmap, status codes, failures by cause, and a log you can open any request from. When the run ends it gives a verdict in plain words, and says where the time went. It takes a curl command as input, ramps load to find where a target stops keeping up, load-tests every endpoint of an OpenAPI spec, replays an access log, and runs a flow of requests where each step feeds the next. `pepe ping` is the same engine at one request a second: a graph of a URL's latency over time, each ping split into DNS, connect, TLS, first byte and download, with what to look at.
  10. It is also light. One thread sends 160k requests a second on an Apple M4 Pro and 400k on Linux, for less CPU and less memory per request than [wrk](https://github.com/wg/wrk), a quarter to a half of [oha](https://github.com/hatoo/oha)'s CPU and a tenth of its memory or less, and pepe tells you when it, rather than the target, is the limit.
  11. ## Install
  12. ```bash
  13. curl -LsSf https://pepe.mhaimdat.com/install.sh | sh # macOS and Linux
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 24 on GitHub
  14. brew install omarmhaimdat/pepe/pepe # Homebrew
  15. nix run github:omarmhaimdat/pepe -- https://example.com # Nix, without installing
  16. docker run --rm -it ghcr.io/omarmhaimdat/pepe https://example.com
  17. cargo install --locked --git https://github.com/omarmhaimdat/pepe
  18. ```
  19. Windows, in PowerShell: `powershell -ExecutionPolicy Bypass -c "irm https://pepe.mhaimdat.com/install.ps1 | iex"`. Every [release](https://github.com/omarmhaimdat/pepe/releases) also ships binaries for macOS, Linux and Windows with checksums and signed provenance, the shell completions and the man pages. `pepe self-update` installs the latest release; pepe looks for one once a day and says so when a run ends. All of it, with the details, on the [install page](https://pepe.mhaimdat.com/docs/install.html).
  20. ## Quick start
  21. ```bash
  22. pepe https://example.com # 100 requests, one per core at a time, and watch
  23. pepe -z 30s -c 50 -m POST -H 'Content-Type: application/json' -d '{"key":"value"}' https://httpbin.org/post
  24. pepe -z 30s --curl -- curl 'https://api.example.com/items' -H 'Authorization: Bearer …' # from "Copy as cURL"
  25. pepe ping https://example.com --once # three pings, then why it is slow, and out
  26. pepe # the setup screen: every option on a form
  27. ```
  28. In the dashboard, `space` pauses, `+` and `-` change concurrency, `tab` switches view, `enter` inspects a request, `?` lists every key, `q` quits and leaves the verdict in your shell.
  29. ## What it does
  30. | Command | What for | Docs |
  31. | --- | --- | --- |
  32. | `pepe URL` | A load test with the live dashboard: the load's shape (`--number`, `--duration`, `--concurrency`, `--rate`, `--warmup`, `--threads`), any header, body or method, a curl command, a `pepe.toml` next to the code, soak runs with `--snapshot` | [Load testing](https://pepe.mhaimdat.com/docs/load-test.html), [The dashboard](https://pepe.mhaimdat.com/docs/dashboard.html) |
  33. | `pepe ping URL…` | A request a second, each split into DNS, connect, TLS, first byte and download, on a graph; several targets, TCP pings, `--slo` limits, HTTP/2, the certificate's expiry, and findings that say what to look at | [Ping](https://pepe.mhaimdat.com/docs/ping.html) |
  34. | `pepe ramp URL` | Raise the concurrency step by step and find the level that held, where throughput stopped following, where it broke, and the capacity estimate | [Ramp](https://pepe.mhaimdat.com/docs/ramp.html) |
  35. | `pepe api SPEC` | The endpoints of an OpenAPI 3 or Swagger 2 spec, picked on screen or by tag, with their parameters and credentials | [OpenAPI](https://pepe.mhaimdat.com/docs/api.html) |
  36. | `pepe flow FILE` | A sequence of requests, each step fed by the one before: log in, take the token, use it | [Flows](https://pepe.mhaimdat.com/docs/flow.html) |
  37. | `pepe replay LOG` | An access log's URLs in their real proportions, sent at another host | [Replay](https://pepe.mhaimdat.com/docs/replay.html) |
  38. | `pepe logs FILES` | What nginx's logs say: the request rate now against each minute, hour and day, paths, errors and the lines themselves, live | [nginx logs](https://pepe.mhaimdat.com/docs/logs.html) |
  39. | `pepe compare A B` | What moved between two reports, in the verdict's words, with a badge and an SVG card | [Compare](https://pepe.mhaimdat.com/docs/compare.html) |
  40. Every flag of every command is in the [command reference](https://pepe.mhaimdat.com/docs/reference.html), and `man pepe` has the same.
  41. ## Scripts, CI and agents
  42. Every mode runs without a screen and is built to be called by a program:
  43. - **A versioned JSON report** with `--json` (`schema_version: 1`; `pepe schema` prints each report's JSON Schema), with the verdict and its findings in it. Piped without `--json`, the text verdict.
  44. - **Exit codes that mean something**: 0 as asked, 1 couldn't start or nothing answered, 2 a usage error or a guardrail, 4 a limit crossed (`--fail-if 'p99 > 300ms'`, a ping's `--slo`).
  45. - **Guardrails** checked before anything is sent: `--allow-host .example.com`, `--max-requests`, `--max-rate`, `--max-concurrency`, and `--dry-run`, which says what would be sent and sends nothing. They can live in `pepe.toml`.
  46. - **A GitHub Action** that runs a test, puts the numbers in the job summary and outputs, holds a pull request against its base branch with `pepe compare`, comments the result and can fail the job: [CI and Docker](https://pepe.mhaimdat.com/docs/ci.html).
  47. - **Prometheus metrics** with `--metrics :9100`, for a soak run or a long ping in Grafana.
  48. - **An MCP server** (`pepe mcp`) that serves the modes as tools for an agent, under the guardrails it was started with; [AGENTS.md](AGENTS.md) is what an agent reads first.
  49. ```yaml
  50. - uses: omarmhaimdat/pepe@v0
  51. with:
  52. url: https://staging.example.com/api/health
  53. args: -z 30s -c 20 --fail-if 'p99 > 300ms'
  54. baseline: auto
  55. comment: true
  56. ```
  57. ## How pepe compares
  58. Measured with the suite in [`bench/`](bench/) against a local server that answers from memory, so the client is the cost being measured. CPU milliseconds per 1,000 requests, peak memory, and the requests per second each tool reported:
  59. | Workload | pepe | oha | vegeta |
  60. | --- | --- | --- | --- |
  61. | GET, 64 connections | **6.2 ms · 9 MB** · 160k req/s | 23.0 ms · 78 MB · 161k req/s | 90.4 ms · 26 MB · 76k req/s |
  62. | GET, 1,000 connections | **6.0 ms · 12 MB** · 163k req/s | 21.6 ms · 101 MB · 147k req/s | 52.7 ms · 92 MB · 131k req/s |
  63. | HTTPS, 64 connections | **6.8 ms · 12 MB** · 142k req/s | 24.8 ms · 60 MB · 156k req/s | 69.8 ms · 30 MB · 90k req/s |
  64. Those are single-thread numbers for pepe on an Apple M4 Pro, where the loopback tops out near 175k requests a second. On Linux (a 4-vCPU arm64 VM, the musl build that is released), with wrk on one thread beside it:
  65. | Workload | pepe | wrk | oha |
  66. | --- | --- | --- | --- |
  67. | GET, 64 connections | **2.4 ms · 4.0 MB** · 398k req/s | 3.5 ms · 4.5 MB · 282k req/s | 6.8 ms · 67 MB · 305k req/s |
  68. | GET, 1,000 connections | **3.2 ms · 5.8 MB** · 296k req/s | 4.4 ms · 7.7 MB · 228k req/s | 5.6 ms · 73 MB · 183k req/s |
  69. | HTTPS, 64 connections | **3.3 ms · 6.0 MB** · 284k req/s | 4.5 ms · 10.8 MB · 218k req/s | 8.1 ms · 42 MB · 250k req/s |
  70. | 10 million requests, 256 connections | **2.9 ms · 4.5 MB** · 343k req/s | 3.3 ms · 4.6 MB · 304k req/s | 6.5 ms · 2,404 MB · 316k req/s |
  71. Every workload, where pepe is level rather than ahead (a slow target at 1,000 connections, 16 KB bodies over TLS), what a glibc build changes, k6, the profiles and the method are in [bench/README.md](bench/README.md). Where a target can take more than one thread sends, pepe says so, and `--threads auto` adds them.
  72. ## Documentation
  73. The manual, page by page, with every option and example, is at [pepe.mhaimdat.com/docs](https://pepe.mhaimdat.com/docs/). Its sources are the Markdown files under [docs/](docs/), and the [command reference](https://pepe.mhaimdat.com/docs/reference.html) is generated from the command definition, so it can't drift from the binary. What changed in each release is in [CHANGELOG.md](CHANGELOG.md); what comes next, in order, in [ROADMAP.md](ROADMAP.md).
  74. ## Contributing
  75. Issues and pull requests are welcome; [CONTRIBUTING.md](CONTRIBUTING.md) has the build, the tests, the generated files, the recordings, the benchmarks and how releases are made.
  76. ## License
  77. MIT. See [LICENSE](LICENSE).
  78. ## Acknowledgements
  79. [tokio](https://github.com/tokio-rs/tokio), [rustls](https://github.com/rustls/rustls), [httparse](https://github.com/seanmonstar/httparse), [h2](https://github.com/hyperium/h2) and [reqwest](https://github.com/seanmonstar/reqwest) for the requests, [ratatui](https://github.com/ratatui/ratatui) and [crossterm](https://github.com/crossterm-rs/crossterm) for the dashboard, [clap](https://github.com/clap-rs/clap) for the command line, and [oha](https://github.com/hatoo/oha), [vegeta](https://github.com/tsenart/vegeta), [wrk](https://github.com/wg/wrk) and [k6](https://github.com/grafana/k6) for being good company on the benchmark table.
install/install.ps1 · Bundled script · 27 lines · 2 findings marked
  1. # pepe's installer for Windows, served at https://pepe.mhaimdat.com/install.ps1
  2. #
  3. # powershell -ExecutionPolicy Bypass -c "irm https://pepe.mhaimdat.com/install.ps1 | iex"
    • Note: Runs a downloaded PowerShell script (iex / Invoke-Expression)
    • Line 3 on GitHub
  4. #
  5. # Runs the release installer (built by cargo-dist; it puts pepe.exe in
  6. # ~\.local\bin and adds that to PATH), then has the new pepe set up tab
  7. # completion for PowerShell: `pepe completions --install`. Set
  8. # PEPE_NO_COMPLETIONS=1 to skip that step.
  9. $ErrorActionPreference = 'Stop'
  10. $installer = if ($env:PEPE_INSTALLER_URL) { $env:PEPE_INSTALLER_URL } else { 'https://pepe.mhaimdat.com/latest/pepe-installer.ps1' }
  11. Invoke-Expression (Invoke-RestMethod -Uri $installer)
  12. if ($env:PEPE_NO_COMPLETIONS) { return }
  13. $candidates = @()
  14. if ($env:CARGO_DIST_FORCE_INSTALL_DIR) { $candidates += $env:CARGO_DIST_FORCE_INSTALL_DIR }
  15. if ($env:XDG_BIN_HOME) { $candidates += $env:XDG_BIN_HOME }
  16. $candidates += Join-Path $HOME '.local\bin'
  17. foreach ($dir in $candidates) {
  18. $pepe = Join-Path $dir 'pepe.exe'
  19. if (Test-Path $pepe) {
  20. Write-Host ''
  21. try { & $pepe completions --install } catch { Write-Warning "tab completion wasn't set up; run: pepe completions --install" }
  22. return
  23. }
  24. }
  25. Write-Host "pepe is installed; run 'pepe completions --install' for tab completion"
install/install.sh · Bundled script · 39 lines · 1 finding marked
  1. #!/bin/sh
  2. # pepe's installer, served at https://pepe.mhaimdat.com/install.sh
  3. #
  4. # curl -LsSf https://pepe.mhaimdat.com/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 4 on GitHub
  5. #
  6. # Runs the release installer (built by cargo-dist; it puts `pepe` in
  7. # ~/.local/bin, or $XDG_BIN_HOME, and adds that to PATH), then has the new
  8. # pepe set up tab completion and the man pages for your shell:
  9. # `pepe completions --install`. Arguments go to the release installer, e.g.
  10. # --no-modify-path. Set PEPE_NO_COMPLETIONS=1 to skip the completion step.
  11. set -eu
  12. installer="${PEPE_INSTALLER_URL:-https://pepe.mhaimdat.com/latest/pepe-installer.sh}"
  13. if command -v curl >/dev/null 2>&1; then
  14. fetch() { curl --proto '=https' --tlsv1.2 -LsSf "$1"; }
  15. elif command -v wget >/dev/null 2>&1; then
  16. fetch() { wget -qO- "$1"; }
  17. else
  18. echo "pepe's installer needs curl or wget" >&2
  19. exit 1
  20. fi
  21. fetch "$installer" | sh -s -- "$@"
  22. # Where the release installer puts the binary: the first of these that is
  23. # set, as in dist-workspace.toml's install-path
  24. if [ -n "${PEPE_NO_COMPLETIONS:-}" ]; then
  25. exit 0
  26. fi
  27. for dir in "${CARGO_DIST_FORCE_INSTALL_DIR:-}" "${XDG_BIN_HOME:-}" "$HOME/.local/bin"; do
  28. if [ -n "$dir" ] && [ -x "$dir/pepe" ]; then
  29. echo
  30. "$dir/pepe" completions --install || \
  31. echo "tab completion wasn't set up; run: pepe completions --install" >&2
  32. exit 0
  33. fi
  34. done
  35. echo "pepe is installed; run 'pepe completions --install' for tab completion" >&2

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.