rgx

A terminal regex tester with real-time matching and multi-engine support

Test and debug regular expressions without leaving your terminal. Written in Rust.

Press F1 in the app for a multi-page cheat sheet with keyboard shortcuts, regex syntax, and engine-specific features.

Who is this for?

rgx is useful if you:

• Work on remote servers where opening a browser isn't practical — SSH sessions, containers, air-gapped environments
• Want to pipe regex results into other commands (echo "log" | rgx -p '\d+' | sort) — regex101 can't do this
• Need to test against specific engine behavior — check if your pattern works in Rust's regex crate vs PCRE2 without guessing
• Prefer staying in the terminal and find the context switch to a browser tab disruptive

If you write regex a few times a month and regex101.com works fine for you, it probably still will. rgx is strongest for developers who do regex-heavy work in terminal-centric workflows.

Features

• Real-time matching — matches update on every keystroke
• Syntax-highlighted pattern input — AST-based coloring for groups, quantifiers, character classes, anchors, and escapes
• 3 regex engines — Rust regex (default), fancy-regex (lookaround/backrefs), PCRE2 (full features)
• Capture group highlighting — distinct colors per group, nested group support
• Plain-English explanations — walks the regex AST to generate human-readable breakdowns
• Replace/substitution mode — live preview with $1, ${name}, $0/$& syntax
• Match detail + clipboard — navigate matches/captures with Up/Down, copy with Ctrl+Y
• Pattern history + undo — Ctrl+Z/Ctrl+Shift+Z undo/redo, Alt+Up/Down browse history
• Context-sensitive cheat sheet — F1 multi-page help: shortcuts, regex syntax, engine-specific features
• Whitespace visualization — toggle with Ctrl+W to show spaces as ·, newlines as ↵, tabs as →
• Mouse support — click to focus/position cursor, scroll to navigate panels
• Engine selector — switch engines with Ctrl+E, see where behavior differs
• Regex flags — toggle case-insensitive, multiline, dotall, unicode, extended
• Stdin pipe support — echo "test string" | rgx '\d+'
• Non-interactive batch mode — rgx -p -t "input" 'pattern' prints matches to stdout and exits
• JSON output — --json outputs structured match data with positions and capture groups
• Colored output — --color auto|always|never highlights matches like grep --color
• Pipeline composability — pipe in, filter, pipe out: cat log | rgx -p '\d+' | sort -n
• regex101 URL export — Ctrl+U generates a regex101.com URL and copies to clipboard
• Project workspaces — -w project.toml saves/loads regex state to a file — track in git
• Shell completions — --completions bash|zsh|fish for tab completion
• Vim mode — optional modal editing (--vim or vim_mode = true) with Normal/Insert modes, h/j/k/l navigation, w/b/e word motions, dd/cc/x editing, and all global shortcuts preserved
• Recipe library — built-in common patterns (email, URL, IP, semver, etc.) — Ctrl+R to browse and load
• Cross-platform — Linux, macOS, Windows

Installation

From crates.io

cargo install rgx-cli

From prebuilt binaries

Download from GitHub Releases.

Shell installer

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/brevity1swos/rgx/releases/latest/download/rgx-installer.sh | sh

Homebrew

brew install brevity1swos/tap/rgx

From source

git clone https://github.com/brevity1swos/rgx.git
cd rgx
cargo install --path .

With PCRE2 engine (requires libpcre2-dev)

cargo install rgx-cli --features pcre2-engine

Usage

# Interactive mode
rgx

# Vim mode (modal editing)
rgx --vim

# Start with a pattern
rgx '\d{3}-\d{3}-\d{4}'

# Pipe text from stdin
echo "Call 555-123-4567 or 555-987-6543" | rgx '\d{3}-\d{3}-\d{4}'

# Use a specific engine
rgx --engine fancy '\w+(?=@)'

# With flags
rgx -i 'hello'

# With replacement template
rgx -r '$2/$1' '(\w+)@(\w+)'

# Non-interactive batch mode (--print / -p)
rgx -p -t "hello 42 world 99" '\d+'    # prints: 42\n99
echo "log line 404" | rgx -p '\d+'     # prints: 404

# Count matches only (--count / -c)
echo "a1 b2 c3" | rgx -p -c '\d+'     # prints: 3

# Extract a specific capture group (--group / -g)
echo "user@host" | rgx -p -g 1 '(\w+)@(\w+)'  # prints: user

# Batch replacement
rgx -p -t "user@host" -r '$2=$1' '(\w+)@(\w+)'   # prints: host=user

# JSON output with match positions and capture groups
echo "error at line 42" | rgx -p '(\d+)' --json

# Colored output (like grep --color)
cat server.log | rgx -p 'ERROR: (.*)' --color always

# Pipeline composability
cat server.log | rgx -p 'ERROR: (.*)' | sort | uniq -c

# Project workspace — save/load regex state to a file
rgx -w ~/project/regex/parse_urls.toml

# Capture final pattern after interactive editing
PATTERN=$(rgx -P)

# Generate shell completions
rgx --completions bash > ~/.local/share/bash-completion/completions/rgx

# Exit codes: 0 = match found, 1 = no match, 2 = error
rgx -p -t "test" '\d+' || echo "no digits found"

Keyboard Shortcuts

Vim Mode (--vim)

All global shortcuts (Ctrl+*, Alt+*, F1, Tab) work in both modes.

Engines

Comparison

vs. terminal alternatives

vs. regex101.com

regex101.com is the more capable tool overall — it has 8 engines, step-through debugging, code generation, shareable permalinks, and a community pattern library. rgx doesn't try to replace it. Where rgx is useful instead:

• Offline/remote work — no browser or internet needed
• Pipeline integration — echo data | rgx -p 'pattern' | next-command — non-interactive batch mode with proper exit codes
• Engine-specific testing — test against Rust's regex crate directly (regex101 doesn't have this engine)
• Workspace save/restore — save your session and pick up later (-w project.toml)
• Bridge to regex101 — Ctrl+U exports your current state as a regex101.com URL for sharing

Configuration

rgx looks for a config file at ~/.config/rgx/config.toml:

default_engine = "rust"  # "rust", "fancy", or "pcre2"
vim_mode = false          # enable vim-style modal editing

Editor & Terminal Integration

VS Code

Install from the VS Code Marketplace, or search "rgx" in the Extensions panel.

Commands (open via Ctrl+Shift+P / Cmd+Shift+P):

• rgx: Open — launch rgx in the integrated terminal
• rgx: Open with Selection — pass selected text as test input
• rgx: Open with Pattern — pass selected text as the regex pattern

Neovim

Using lazy.nvim:

{ dir = "path/to/rgx/plugin/nvim" }

Or copy plugin/nvim/lua/rgx/init.lua to your Neovim config:

require("rgx").setup()

Commands:

• :Rgx — open rgx in a floating terminal
• :Rgx pattern — open with a pre-filled pattern
• Visual select + :'<,'>Rgx — pass selection as test input

Zed

Copy plugin/zed/tasks.json to your project's .zed/tasks.json (or merge into an existing one).

Run tasks via Cmd+Shift+P → "task: spawn" → select an rgx task.

tmux

# Open rgx in a tmux popup
tmux display-popup -E -w 80% -h 80% rgx

# Open with a pattern
tmux display-popup -E -w 80% -h 80% -- rgx '\d+'

Contributing

See CONTRIBUTING.md for details.

License

Licensed under either of

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

at your option.