Why are .NET balancing groups flagged?

Balancing groups (? ...) are a .NET-only feature for matching nested constructs by pushing and popping a capture stack. JavaScript has no equivalent, so the converter warns instead of producing broken output.

How are .NET's two named-group forms handled?

.NET accepts both (? ...) and (?'name'...). The converter normalizes the quote form to angle brackets, which works in both JS and .NET.

Are conditional groups supported?

No. .NET's (?(name)yes|no) conditional groups have no JavaScript counterpart. The converter emits a warning and leaves the construct in place so you can refactor manually.

Is conversion run locally?

Yes. The pattern stays in your browser throughout.

javascript · .net · two-way · local

Translate regex between JavaScript and .NET

Convert named groups, inline flags, and balancing-group constructs in both directions. Warnings flag .NET-only features like (?<a-b>) and conditionals that JavaScript can't express.

JS ↔ .NET Regex Converter

Direction

JavaScript regex

.NET regex

^(?<key>\w+)=(?<value>.*)$

Conversions & warnings (2)

info(?<name>...) works identically in .NET. .NET also accepts (?'name'...).
info.NET adds balancing groups (?<a-b>...) and conditional (?(name)yes|no) JS lacks.

Quick Start

How to convert between JavaScript and .NET

Paste a regex in either flavour, pick the direction, and read the translated pattern alongside a list of conversions and warnings.

01
Pick a direction
Choose JS → .NET or .NET → JS. The shell switches placeholders and labels automatically.
Patterns are parsed with 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.
patternECMAScriptliteralregex
input · literaldirection · regex
```
JS -> .NET
```
loaded · ECMAScriptPCRE · ready
02
Paste pattern
Drop your regex in. Named groups (?<n>) ↔ (?'n'), inline flags, and balancing groups are all examined.
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
```
(?<name>\w+)
```
flags applied · liveECMA · live
03
Read translation
Conversions list every rewrite — like (?<name>) staying as (?<name>) since both accept it. Warnings call out .NET-only features.
Conversions translate flavour-specific constructs (lookarounds, named groups, character classes) — the converter flags anything that has no equivalent in the target engine.
convertflavourPCRE · RE2diff
run · outputdiff · converted
```
(?<name>\w+)
```
matches · livediff · ready
04
Copy result
Grab the converted pattern with one click and drop it into your C# / VB.NET / F# codebase.
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’t parsers

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

Use Cases

When you need .NET-aware translation

Bridging JavaScript regex with .NET 's System.Text.RegularExpressions engine.

Port to C#

Lift a JS validator into a .NET service without rewriting from scratch. 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

ASP.NET routes

Reuse JS path patterns inside attribute routing constraints. 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

PowerShell scripts

Translate JS patterns for use in PowerShell -match operators. 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

Document differences

Show colleagues which features changed across the two engines. 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

Audit named groups

Catch (?<name>) vs (?'name') mismatches before they cause silent fails. 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

Cross-language tests

Verify the same pattern behaves identically in JS and .NET. 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

What's different about .NET regex?

.NET adds balancing groups (?<a-b>...) and conditional (?(name)yes|no) patterns that JavaScript lacks. Named groups also accept (?'name'...) as an alternate syntax.

Are named groups converted?

(?<name>...) works identically in both engines. .NET also accepts (?'name'...), which is normalised to (?<name>) when going to JS.

What about balancing groups?

.NET-only. The converter emits a warning when balancing groups are detected going to JS, since there's no equivalent construct.

Are inline flags handled?

Yes. .NET inline flags like (?ix) are stripped when going to JS, with a warning explaining the implicit flag change.

Is anything sent to a server?

No. The conversion happens entirely in your browser.

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!