⌘ K
glob → regex · {a,b} · ** · live

Convert shell globs into regex

Drop in *, **, ?, character classes, brace expansion — get an equivalent regex you can paste into code or grep. Runs locally.

Glob to Regex
Matched
1
paths
Failed
3
paths
Length
28
chars
Status
ready
live
input · glob + sample paths
Test paths
* → [^/]* (one segment)
** → .* (any depth)
? → [^/] (one char)
[abc] → [abc] (char class, ! → ^)
{a,b,c} → (?:a|b|c) (brace expansion)
output · regex + verification
Equivalent regex
^src/.*[^/]*\.([^/]:ts|tsx)$
Matches (1)
src/components/foo/bar.tsx
Non-matching (3)
src/index.ts
src/foo.js
lib/x.ts
Quick Start

How to convert a glob to a regex

Drop in a shell glob — *, **, ?, [...], {a,b} — and get an equivalent regex you can use in code or grep.

  1. 01

    Paste glob

    Standard shell globs work. Brace expansion {ts,tsx} too.

    Patterns compile through the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) work when the u flag is on.

    patternECMAScriptliterallive
    input · literalglob · regex
    src/**/*.{ts,tsx}
    loaded · ECMAScriptPCRE · ready
  2. 02

    Read the regex

    * becomes [^/]*, ** becomes .*, ? becomes [^/]. Brace alternations become non-capturing groups.

    Each flag character mirrors the ECMAScript literal: g enables iteration, i folds case, m anchors per line, s lets . match newlines, u unlocks proper Unicode, y is sticky, and d emits indices.

    flagsoptionsg · i · mlive
    config · optionsregex · flags
    ^src/.*\.(?:ts|tsx)$
    flags applied · liveECMA · live
  3. 03

    Test paths

    Drop one path per line. Pass/fail per line confirms the conversion.

    Watch for catastrophic backtracking on nested quantifiers — a common ReDoS source. The tool caps match counts to keep the page responsive on pathological patterns.

    matchgroupshighlightReDoS-safe
    run · outputverify · matches
    ok src/foo/bar.tsx
    matches · livegroups · live
  4. 04

    Copy or export

    Grab the output as JSON, CSV, or plain text — ready for your editor or pipeline.

    Copy writes via navigator.clipboard.writeText; downloads use a Blob and object URL, so nothing transits the network and the output is byte-identical to what you see on screen.

    copyexportclipboardblob
    export · exportedready · saved
    Copied
    ready to shipsuccess
Pro tips

Regex patterns that don't melt down

Use named groups

(?<year>\d{4}) reads better than $1 and survives reordering. Supported in ECMAScript 2018+.

Anchor strictly

Use ^/$ with the m flag when matching whole lines. Without anchors, partial matches sneak through.

Avoid catastrophic backtracking

Nested quantifiers like (a+)+ can explode. Run patterns through ReDoS Detector first.

Escape every literal

Backslash any meta character you want literally: \.\$\^\*\+\?\(\)\[\]\{\}\|\\.

Test edge cases

Empty string, single character, unicode, the maximum length you expect — write fixtures for each.

Patterns aren&rsquo;t parsers

Don’t parse HTML, JSON, or balanced parens with regex. Use a proper parser when the grammar is recursive.

Related toolsRegex To GlobGitignore To RegexRegex TesterRegex BuilderRegex ExplainerRegex Cheatsheet
Use Cases

When to convert globs

Port shell-style globs to regex-aware tools.

Port .gitignore

Reuse gitignore-style globs in JS code. Compiles through the JavaScript RegExp constructor — engine quirks (Unicode property escapes, sticky matching, named groups) work when their flags are on. Error messages cite the exact position of any syntax issue.

ReDoS-safe

File filters

Match files in build scripts with regex. Pairs with the ReDoS detector to catch catastrophic backtracking before you deploy. A pattern that handles 1k-character input fine can become a denial-of-service vector on attacker-controlled 1M-character input.

ECMA-compliant

CI patterns

Translate glob CI filters into regex tooling. Output exports as JavaScript, Python re, Java util.regex, .NET System.Text.RegularExpressions, PCRE, and POSIX — language quirks are highlighted on conversion so you don't ship a JS-only pattern to a Go service.

spec-grade

Doc conversion

Show readers both forms side by side. Capture groups (named or numbered) round-trip cleanly into replacement strings, JSON output, or CSV extraction without re-typing. Backreferences ($1, ${name}) preserve semantics across languages.

cross-engine

Test framework filters

Convert Jest globs to mocha regex. Test against edge cases — empty input, single character, max length, multibyte boundaries — to catch off-by-one and zero-length match bugs before they reach production.

test-ready

Verify intent

Eyeball the regex to confirm globs do what you expect. All matching runs client-side so secret patterns never leave the browser. Useful when the pattern itself is sensitive (PII regexes, internal data formats, security filters).

production-ready
FAQ

Frequently asked questions

* matches one segment (no /). ** matches across segments. The conversion respects that — * becomes [^/]*, ** becomes .*.
Yes — {a,b,c} becomes (?:a|b|c).
Not supported. Use the Regex Builder for complex patterns or convert manually.
Yes — like most shells. Add the i flag manually if you need case-insensitive matching.
No. The tool runs entirely in your browser — your pattern and sample text never leave the page.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!