What's the difference between ordered and simultaneous mode?

Ordered applies each rule one after the other, so an earlier replacement can become the input for a later one. Simultaneous applies all rules against the original text, avoiding cascading effects.

Are capture groups supported?

Yes. Regex rows can reference $1, $2, etc. in their replacements to insert captured groups.

Does anything leave my browser?

No. Rules and input are processed locally; nothing is uploaded.

many rules · regex per rule · live

Apply many find & replace rules at once

Q: Can each rule use regex independently?

Yes. Every row has its own literal/regex toggle and its own case-sensitivity flag, so you can mix exact phrases and pattern rules in the same batch.

Define multiple find/replace pairs (with optional regex per pair) and apply them sequentially in one pass.

Bulk Find & Replace Workspace

Input size

127 B

3 lines

Output size

133 B

after rules

Total replaces

3 active rules

Status

case-insens

rules · find → replace

FindReplaceRegex

input · text & output below

output · replaced

The slow brown fox jumps over the energetic dog.
She sells seashells by the seashore.
GROCER GROCER picked a peck of pickled GROCERs.

Quick Start

How to bulk find & replace

Define multiple rules at once — each pair has its own regex toggle. Rules apply in order, so later rules see the output of earlier ones.

01
Paste source text
Your input goes in the right pane. Rules are listed on the left.
Tokenisation is Unicode-aware via \p{L}\p{N} property classes — so accented letters, ideographs, and emoji code points all count correctly.
any textUTF-8Unicodecode pointslive
input · textsource · UTF-8
```
The quick brown fox…
```
loaded · UTF-8UTF-8 · ready
02
Add rules
Each rule = find + replace + optional regex toggle. Click + Add pair for more.
Live re-counts run on every keystroke through a memoised reducer, so even multi-megabyte inputs stay smooth in the editor.
pairslivememoisedoptionssnappy
rules · options3 · live
```
quick → slow
lazy → energetic
```
options applied · livelive
03
Sequential application
Rules apply in order. If rule 2 matches what rule 1 produced, that's by design — chain transformations carefully.
Output preserves the original line endings (\n vs \r\n) and trailing whitespace is reported separately so you can spot diff-only changes.
sequentialline endingswhitespacediff-cleanreproducible
order · countedapplied · ready
```
output → rule 1 → rule 2 → final
```
counted · livecounted
04
Copy or download
One-click copy or download as text/markdown.
Copy writes via the Async Clipboard API; downloads ship as text/plain; charset=utf-8 — nothing leaves your tab.
copydownloadclipboardtext/plainblob
export · copiedready · done
```
✓ Copied
```
shipped · ready to shipsuccess

Pro tips

Text-processing fundamentals worth knowing

Tokenise with Unicode classes

Use \p{L}\p{N} with the u flag so accents, ideographs, and emoji count properly.

Normalise line endings

Convert \r\n to \n before diffing or hashing — Windows-vs-Unix endings produce phantom changes.

Mind invisible characters

Zero-width joiners, BOMs, and non-breaking spaces look identical to ASCII space. Strip them before comparison or storage.

Stream don’t slurp

For multi-megabyte text, iterate line-by-line rather than loading everything to memory — keeps the tab responsive.

Choose collation deliberately

Default JS sort is code-point order, not human alphabetical. Use Intl.Collator for locale-aware sorting.

Re-run after normalisation

NFC vs NFD changes byte length but not visible glyphs. String.prototype.normalize() before counts and comparisons.

Use Cases

When to bulk-replace

Anywhere you'd otherwise pipe sed commands together.

Codemod-light

Apply a few hand-crafted renames across pasted code. Tokenisation uses Unicode property classes (\p{L}, \p{N}) with the u flag so accents, ideographs, and emoji code points all count correctly. Surrogate-pair-aware counts mean 🚀 weighs 1, not 2.

Unicode-correct

Log redaction

Multiple redaction patterns in one pass (tokens, IPs, emails). Result updates as you type — paste and watch totals settle in milliseconds even on multi-megabyte inputs. Heavy work runs through a memoised reducer so the editor never janks.

diff-clean

Markdown cleanup

Convert several inline patterns at once (links, bullets, code marks). Output normalises line endings to LF for clean diffs across platforms. Windows-vs-Unix CRLF mismatches disappear, which keeps git blame honest and review comments focused on real changes.

instant counts

Document translate

Apply many glossary swaps in one pass. Code-point counts are stable across NFC/NFD normalisation. Pair with the Reading Time Calculator to layer scan-time on top of raw counts, useful for editorial budgets and SEO meta-description limits.

i18n-friendly

URL rewrites

Update domain or path patterns in copied content. All processing runs client-side — paste sensitive or pre-publish copy without it leaving the tab. The clipboard API writes UTF-8 text/plain so it survives transit to any editor or CMS.

code-point-accurate

Config migration

Several rename rules for a config schema change. Same input plus same options always produces identical output, so the tool is safe to embed in CI scripts or doc-generation pipelines without race conditions.

lossless

FAQ

Frequently asked questions

Can each rule use regex independently?

Yes — each pair has its own regex toggle. Mix literal and regex rules freely.

What's the global case setting?

The Case-sensitive checkbox applies to ALL rules. There's no per-rule case toggle.

Are rules sequential or parallel?

Sequential — rule 2 sees what rule 1 produced. Order matters.

What if a rule errors?

An invalid regex aborts the whole pass and shows the error. Fix the rule and the output recovers.

Is anything sent to a server?

No. All processing runs locally.

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!