rg Code Search Expert knowledge for using rg (ripgrep) as a blazingly fast code search tool with powerful filtering and pattern matching. Core Expertise ripgrep Advantages Extremely fast (written in Rust) Respects .gitignore automatically Smart case-insensitive search Recursive by default Colorized output Multi-line search support Replace functionality Basic Usage Simple Search

Basic search

rg pattern

Search in current directory

rg "import numpy"

Search for exact phrase

rg function_name

Search for function name

Case-sensitive search

rg -s Pattern

Force case-sensitive

rg -i PATTERN

Force case-insensitive

File Type Filtering

Search specific file types

rg pattern -t py

Python files only

rg pattern -t rs

Rust files only

rg pattern -t js

JavaScript files

rg pattern -t md

Markdown files

Multiple types

rg pattern -t py -t rs

Python and Rust

List available types

rg --type-list

Show all known types

Extension Filtering

Filter by extension

rg pattern -g '*.rs'

Rust files

rg pattern -g '*.{js,ts}'

JavaScript and TypeScript

rg pattern -g '!*.min.js'

Exclude minified files

Advanced Patterns Regular Expressions

Word boundaries

rg '\bfunction\b'

Match whole word "function"

rg '\btest_\w+'

Words starting with test_

Line anchors

rg '^import'

Lines starting with import

rg 'return$'

Lines ending with return

rg '^class \w+:'

Python class definitions

Character classes

rg 'TODO|FIXME|XXX'

Find markers

rg '[Ee]rror'

Error or error

rg '\d{3}-\d{4}'

Phone numbers

Multi-line Search

Multi-line patterns

rg -U 'fn.{.}'

Function definitions (Rust)

rg -U 'struct.{[^}]}'

Struct definitions

Context lines

rg -A 5 pattern

Show 5 lines after

rg -B 3 pattern

Show 3 lines before

rg -C 2 pattern

Show 2 lines before and after

Output Formatting

Control output

rg -l pattern

List files with matches only

rg -c pattern

Count matches per file

rg --count-matches pattern

Total match count

Show context

rg -n pattern

Show line numbers (default)

rg -N pattern

Don't show line numbers

rg --heading pattern

Group by file (default)

rg --no-heading pattern

Don't group by file

Customize output

rg --vimgrep pattern

Vim-compatible format

rg --json pattern

JSON output

Advanced Filtering Path Filtering

Search in specific directories

rg pattern src/

Only src/ directory

rg pattern src/ tests/

Multiple directories

Exclude paths

rg pattern -g '!target/'

Exclude target/

rg pattern -g '!{dist,build,node_modules}/'

Exclude multiple

Full path matching

rg pattern -g '/test/'

Only test directories

Content Filtering

Search only in files containing pattern

rg --files-with-matches "import.*React" | xargs rg "useState"

Exclude files by content

rg pattern --type-not markdown

Search only uncommitted files

rg pattern $( git diff --name-only ) Size and Hidden Files

Include hidden files

rg pattern -u

Include hidden

rg pattern -uu

Include hidden + .gitignore'd

rg pattern -uuu

Unrestricted: everything

Exclude by size

rg pattern --max-filesize 1M

Skip files over 1MB

Code Search Patterns Finding Definitions

Function definitions

rg '^def \w+('

Python functions

rg 'fn \w+('

Rust functions

rg '^function \w+('

JavaScript functions

rg '^\s*class \w+'

Class definitions

Interface/type definitions

rg '^interface \w+'

TypeScript interfaces

rg '^type \w+ ='

Type aliases

rg '^struct \w+'

Struct definitions (Rust/Go)

Finding Usage

Find function calls

rg 'functionName('

Direct calls

rg '.methodName('

Method calls

Find imports

rg '^import.*module_name'

Python imports

rg '^use.*crate_name'

Rust uses

rg "^import.*'package'"

JavaScript imports

Code Quality Checks

Find TODOs and FIXMEs

rg 'TODO|FIXME|XXX|HACK'

Find all markers

rg -t py '#\s*TODO'

Python TODOs

rg -t rs '//\s*TODO'

Rust TODOs

Find debug statements

rg 'console.log'

JavaScript

rg 'println!'

Rust

rg 'print('

Python

Find security issues

rg 'password.=|api_key.='

Potential secrets

rg 'eval('

Eval usage

rg 'exec('

Exec usage

Testing Patterns

Find tests

rg '^def test_' -t py

Python tests

rg '#[test]' -t rs

Rust tests

rg "describe(|it(" -t js

JavaScript tests

Find skipped tests

rg '@skip|@pytest.mark.skip' -t py rg '#[ignore]' -t rs rg 'test.skip|it.skip' -t js File Operations Search and Replace

Preview replacements

rg pattern --replace replacement

Perform replacement (requires external tool)

rg pattern -l | xargs sed -i 's/pattern/replacement/g'

With confirmation (using fd and interactive)

fd -e rs | xargs rg pattern --files-with-matches | xargs -I { } sh -c 'vim -c "%s/pattern/replacement/gc" -c "wq" {}' Integration with Other Tools

Pipe to other commands

rg -l "TODO" | xargs wc -l

Count lines with TODOs

rg "function" --files-with-matches | xargs nvim

Open files in editor

Combine with fd (prefer fd's native -x execution)

fd -e py -x rg "class.*Test" { }

Find test classes

fd -e rs -x rg "unsafe" { }

Find unsafe blocks

Count occurrences

rg -c pattern | awk -F: '{sum+=$2} END {print sum}' Stats and Analysis

Count total matches

rg pattern --count-matches --no-filename | awk '{sum+=$1} END {print sum}'

Find most common matches

rg pattern -o | sort | uniq -c | sort -rn

Files with most matches

rg pattern -c | sort -t: -k2 -rn | head -10 Performance Optimization Speed Tips

Limit search

rg pattern --max-depth 3

Limit directory depth

rg pattern -g '*.rs' -t rust

Use type filters

Parallel processing (default)

rg pattern -j 4

Use 4 threads

Memory management

rg pattern --mmap

Use memory maps (faster)

rg pattern --no-mmap

Don't use memory maps

Large Codebase Strategies

Narrow scope first

rg pattern src/

Specific directory

rg pattern -t py -g '!test*'

Specific type, exclude tests

Use file list caching

rg --files

/tmp/files.txt rg pattern $( cat /tmp/files.txt )

Exclude large directories

rg pattern -g '!{target,node_modules,dist,build}/' Best Practices When to Use rg Searching code for patterns Finding function/class definitions Code analysis and auditing Refactoring support Security scanning When to Use grep Instead POSIX compatibility required Simple one-off searches Piped input (stdin) System administration tasks Tips for Effective Searches Escape regex special characters in patterns Use -u flags when searching ignored/hidden files Exclude large binary/generated files with --glob '!vendor' Prefer rg over grep for speed and smart defaults Quick Reference Essential Options Option Purpose Example -t TYPE File type filter rg -t py pattern -g GLOB Glob pattern rg -g '.rs' pattern -i Case-insensitive rg -i pattern -s Case-sensitive rg -s Pattern -w Match whole words rg -w word -l Files with matches rg -l pattern -c Count per file rg -c pattern -A N Lines after rg -A 5 pattern -B N Lines before rg -B 3 pattern -C N Context lines rg -C 2 pattern -U Multi-line rg -U 'pattern.' -u Include hidden rg -u pattern --replace Replace text rg pattern --replace new File Types (Common) Type Extensions -t py Python (.py, .pyi) -t rs Rust (.rs) -t js JavaScript (.js, .jsx) -t ts TypeScript (.ts, .tsx) -t go Go (.go) -t md Markdown (.md, .markdown) -t yaml YAML (.yaml, .yml) -t json JSON (.json) Common Command Patterns

Find function definitions across codebase

rg '^\s*(def|fn|function)\s+\w+' -t py -t rs -t js

Find all imports

rg '^(import|use|require)' -t py -t rs -t js

Find potential bugs

rg 'TODO|FIXME|XXX|HACK|BUG'

Find test files and count tests

rg -t py '^def test_' -c

Find large functions (50+ lines)

rg -U 'def \w+.\n(.\n){50,}' -t py

Security audit

rg 'password|api_key|secret|token' -i -g '!*.{lock,log}' This makes rg the preferred tool for fast, powerful code search in development workflows.