Does it run the regex on any data?

No. The tool only parses and pretty-prints the pattern. For testing matches, use a dedicated regex tester.

Is my pattern uploaded?

No. Parsing runs in your browser. Patterns containing internal identifiers or hostnames stay on the device.

Which flavour of regex does it support?

JavaScript regex syntax (ECMAScript) including the u and v flags. PCRE features without a JS equivalent may not parse.

Will it flag errors in my pattern?

Yes. Parse errors are reported with their position so you can locate unbalanced brackets or invalid escapes.

regex · indent · groups · live

Pretty-print a regular expression

Splits a regex at group boundaries and alternation, indenting each level so you can finally read it. Character classes stay on one line. Runs locally.

Regex Formatter

Input

38 B

1 lines

Output

69 B

16 lines

Status

ready

live

Ratio

1.82×

out/in

input · regex

output · formatted

/^
(
  ?:
  (
    [a-z]+
  )
  :\/\/
)
?
(
  [^\/]+
)
(
  \/.*
)
?$/i

Quick Start

How to format a regex

Tokenises the pattern character by character — escapes survive, [character classes] stay intact, parens open new indent levels, alternation marks live at the parent depth.

01
Paste the pattern
Either /pattern/flags or just the raw pattern. Flags survive when wrapped in slashes.
Parsing runs through Prettier’s standalone bundle (or the language-specific equivalent) loaded lazily — no parser ships until the tool is opened.
regexPrettierASTstandalonelazy
input · sourceraw · AST
```
/(foo|bar)+/i
```
loaded · parsedAST · ready
02
Tokeniser runs
Each backslash-escape is consumed as a pair; [classes] are skipped until ]; parens drive depth.
Indent width, tab style, and print-width re-format through a memoised pass — switching 2 → 4 spaces never re-parses, only re-prints.
lexindentprint-widthmemoisedlive
tok · optionsscan · live
```
( | )
```
options applied · livelive
03
Watch tree form
Open paren opens a level; close paren closes it. | marks alternation at the parent depth.
The formatter is deterministic and idempotent: running it twice produces byte-identical output, which keeps diffs and git noise to a minimum.
liveidempotentdeterministicdiff-cleanstable
out · formattedtree · ready
```
(
  foo
|
  bar
)+
```
formatted · liveidempotent
04
Copy or download
Grab the tree as text or copy to clipboard. Input stays in your browser.
Download writes a Blob with the language-appropriate extension; copy uses navigator.clipboard.writeText so the output preserves all whitespace exactly.
exportclipboardbloblanguage MIMEclient-side
ok · copiedready · done
```
OK Copied
```
shipped · ready to shipsuccess

Pro tips

Formatting tips that keep diffs sane

Pick one config and pin it

Inconsistent formatting causes diff churn. Commit .prettierrc / .editorconfig and enforce in CI.

Format on save

Editor integration is faster feedback than a pre-commit hook. Use both for belt-and-braces.

Idempotency matters

Running the formatter twice should produce identical output. Test this on a representative file.

Match the language community

Default to community conventions: 2 spaces for JS/CSS, 4 for Python, tabs for Go. Fights over indent are a productivity tax.

Print-width drives wrapping

80, 100, and 120 are the common targets. Wider lines parse fast but review slower side-by-side.

Don’t mix formatters and linters

Prettier handles whitespace; ESLint handles correctness. Disable overlapping rules to avoid fight-club configs.

Use Cases

When to format regex

Debugging, code reviews, documentation.

Debugging

See group structure of a tricky pattern. Idempotent: running the formatter twice produces byte-identical output, which is the foundation of a clean CI gate. Pair with a pre-commit hook so PRs arrive already formatted, focusing review on logic.

idempotent

Code reviews

Make a one-line regex reviewable in a PR. Pairs with EditorConfig + .prettierrc for end-to-end consistency. Whitespace-only changes vanish so reviewers see real diffs, and git blame stays honest about who wrote what.

CI-ready

Docs examples

Pretty-print patterns for blog posts. Output respects your indent width, tab style, and print-width — settings carry over for repeat runs. Switching 2-space to 4-space costs nothing in CPU but standardises an entire codebase.

diff-clean

Migration

Re-express a Perl regex for a JS engine. Format-on-save is the fastest feedback loop; CI is the safety net. Together they make inconsistent indentation a thing of the past and free up review cycles for genuine concerns.

PR-friendly

Quick read

Skim long URL / route patterns. Whitespace-only changes don't trigger downstream content-hash invalidations, so CDN cache keys and CI cache layers stay warm. Real changes get all the rebuild budget.

review-ready

Teaching

Show students how groups nest visually. Pairs with linters (ESLint, Stylelint, pylint) that catch what formatting alone can't — bugs, unused imports, dead code. Each tool stays in its lane, and the codebase stays clean.

deterministic

FAQ

Frequently asked questions

Will it validate the regex?

No. We only reformat the text. Test it in a real regex engine separately.

What about lookahead syntax?

(?=...) / (?!...) / (?<=...) parens are treated like ordinary groups for indenting.

Will named groups be touched?

No — (?<name>...) is preserved verbatim as text.

What flags survive?

Flags are kept when the pattern is wrapped in /.../ slashes. Plain patterns return no flags.

Is anything sent to a server?

No — the formatter runs locally in your browser tab.

Suggest a tool

Something missing?

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

47 in queue·8 shipped this month

Request queued. Thanks!