No Results Found¶

If ripgrep returns zero results when you expect matches, try these troubleshooting steps:

flowchart TD
    Start[No Results Found] --> Files{"Are expected files
being searched?"}
    Files -->|Check with --files| Listed{"Files in
--files output?"}

    Listed -->|No| Gitignore{"Filtered by
.gitignore?"}
    Gitignore -->|Yes| UseU["Use -u/-uu/-uuu
to bypass ignores"]
    Gitignore -->|No| Hidden{Hidden files?}

    Hidden -->|Yes| UseHidden[Use --hidden flag]
    Hidden -->|No| Type{Wrong type filter?}

    Type -->|Yes| FixType["Use -g glob or
check --type-list"]

    Listed -->|Yes| Binary{Binary files?}
    Binary -->|Yes| UseText[Use -a/--text flag]
    Binary -->|No| Case{Case mismatch?}

    Case -->|Yes| UseI[Use -i or -S flag]
    Case -->|No| Pattern{Pattern issue?}

    Pattern -->|Regex| TestF[Test with -F literal]
    Pattern -->|Multiline| UseU2[Use -U multiline]

    UseU --> Retest[Re-run search]
    UseHidden --> Retest
    FixType --> Retest
    UseText --> Retest
    UseI --> Retest
    TestF --> Retest
    UseU2 --> Retest

    Retest --> Found{Results found?}
    Found -->|Yes| Success[Problem Solved]
    Found -->|No| Debug[Use --debug for details]

    style Start fill:#ffebee
    style Files fill:#fff3e0
    style Success fill:#e8f5e9
    style Debug fill:#e1f5ff

Figure: Diagnostic decision tree for troubleshooting "no results" issues.

Check What Files Would Be Searched¶

$ rg --files

$ rg --files -t rust           # See which Rust files would be searched
$ rg --files -g "*.config"     # See which .config files would be searched
$ rg --files --hidden          # Include hidden files in the listing

Files Filtered by .gitignore¶

Diagnosis: Run with --debug to see if files are being ignored (see Debug Flags for more details):

# Source: docs/troubleshooting/debug-flags.md
$ rg --debug "pattern"
DEBUG|ignore::walk|ignore_match: ... ignore rule IgnoreMatch(Gitignore(Explicit { from: Some(".gitignore"), original: Some("node_modules/"), ... }))
DEBUG|ignore::walk: ignoring ./node_modules: Ignore(IgnoreMatch(Gitignore(Explicit { ... })))  # (1)!
DEBUG|ignore::walk|ignore_match: ... ignore rule IgnoreMatch(Gitignore(Explicit { from: Some(".gitignore"), original: Some("target/"), ... }))
DEBUG|ignore::walk: ignoring ./target: Ignore(IgnoreMatch(Gitignore(Explicit { ... })))

1. These lines show which directories are being ignored and which .gitignore rule caused the filtering. The from field indicates the source file (.gitignore), and original shows the exact pattern that matched.

graph LR
    All[All Files in Directory] --> VCS{".gitignore
.git/info/exclude"}
    VCS -->|Filtered| Ignored1[Ignored Files]
    VCS -->|Pass| Custom{".ignore
.rgignore"}

    Custom -->|Filtered| Ignored2[Ignored Files]
    Custom -->|Pass| Hidden{"Hidden Files
starting with ."}

    Hidden -->|Filtered| Ignored3[Hidden Files]
    Hidden -->|Pass| Binary{"Binary Files
with NUL bytes"}

    Binary -->|Filtered| Ignored4[Binary Files]
    Binary -->|Pass| Type{"File Type
-t filter"}

    Type -->|Filtered| Ignored5[Non-matching Types]
    Type -->|Pass| Searched[Files Searched]

    style All fill:#e3f2fd
    style Searched fill:#e8f5e9
    style Ignored1 fill:#ffebee
    style Ignored2 fill:#ffebee
    style Ignored3 fill:#ffebee
    style Ignored4 fill:#ffebee
    style Ignored5 fill:#ffebee

Figure: ripgrep's filtering layers - files must pass all filters to be searched.

Solutions:

$ rg -u "pattern"

$ rg -uu "pattern"

$ rg -uuu "pattern"

$ rg --no-ignore-vcs "pattern"

Hidden Files Skipped¶

Problem: ripgrep skips hidden files and directories (those starting with .) by default.

Solutions: - Use --hidden to search hidden files - Use -uuu to search everything including hidden files

Binary Files Filtered¶

For more details, see the Binary and Encoding Problems page.

Diagnosis: Run with --debug to see binary file detection:

# Source: docs/troubleshooting/debug-flags.md
$ rg --debug "pattern"
DEBUG|grep_searcher::searcher: fast BoyerMoore search
DEBUG|grep_searcher::searcher: binary file matches (but not printed): ./myfile.bin  # (1)!
DEBUG|grep_searcher::searcher: searching ./script.sh: binary detection: false
DEBUG|grep_searcher::searcher: binary file matches (but not printed): ./data.db

1. These lines indicate which files were detected as binary. When "binary file matches (but not printed)" appears, it means the file was searched, matches were found, but results weren't printed because a NUL byte (\0) was detected. Text files show "binary detection: false".

Solutions:

• Use -a or --text to search binary files anyway
• Use --binary to explicitly control binary file handling

Case Sensitivity¶

Problem: The pattern doesn't match because of case differences.

Solutions: - Use -i or --ignore-case to make the search case-insensitive - Use -S or --smart-case to search case-insensitively if the pattern is all lowercase - Check if smart-case is enabled in your configuration file

File Type Not Recognized¶

Problem: Files are being filtered out because their type isn't recognized or matched by your -t filter.

Diagnosis: Use --type-list to see all file types ripgrep knows about:

$ rg --type-list

This shows all available file types and their associated patterns. Check if your file type is listed and what extensions/patterns it matches.

$ rg --type-list | grep -i rust
rust: *.rs

$ rg --type-list | grep -i python
py: *.py, *.pyw, *.pyi, *.pyx

Solutions:

• If your file type isn't in the list, use -g glob patterns instead of -t:

  $ rg "pattern" -g "*.myext"
  

• Check that you're using the correct type name (e.g., py not python)
• Add custom file types in your configuration file using --type-add:

# Source: docs/configuration-file.md
# Add custom type for web development
--type-add
web:*.{html,css,js,jsx,ts,tsx}*

# Add custom type for configuration files
--type-add
config:*.{json,yaml,yml,toml,ini}*

$ rg "pattern" -t web      # Search only web files
$ rg "pattern" -t config   # Search only config files

Pattern Doesn't Match¶

Problem: Your regex pattern isn't matching what you expect.

Diagnosis:

• Use -F or --fixed-strings to search for literal text instead of a regex
• Test with a simpler pattern to verify the file is being searched
• Use --debug to see the literal prefixes ripgrep extracted from your pattern

$ rg "foo.*bar"      # regex search (matches "foo123bar", "fooXYZbar", etc.)
$ rg -F "foo.*bar"   # literal search for the exact string "foo.*bar"

# Source: docs/common-options/search-basics.md
# Match function definitions spanning multiple lines
$ rg -U 'fn \w+\([^)]*\)\s*->'

# Find multi-line comments
$ rg -U '/\*.*?\*/'

# Match struct definitions with any content between braces
$ rg -U --multiline-dotall 'struct \w+ \{.*?\}'

Common Search Recipes¶

Here are combined flag combinations for typical "no results" scenarios:

# Search all files including ignored, hidden, and binary files
$ rg -uuu "pattern"

# Search ignored directories but skip hidden and binary files
$ rg -uu "pattern"

# Search hidden files like .env, .config, etc.
$ rg --hidden -g ".*" "pattern"

# Find literal text like "foo.*bar" or "user@example.com"
$ rg -F "exact.text.with.special.chars"

# Ignore case, search all text files including ignored ones
$ rg -i -uu "pattern"

# Search only Rust files, including those in ignored directories
$ rg -u -t rust "pattern"

# Show detailed filtering decisions
$ rg --debug "pattern" 2>&1 | grep -i "ignoring\|binary"

See Also¶

• Debug Flags - Comprehensive guide to diagnostic flags
• Binary and Encoding Problems - Troubleshooting binary file and encoding issues
• Search Basics - Pattern matching fundamentals
• Configuration File - Setting up custom file types and default options