Find and Replace Without Regex

A dot is a dot

Search a.c in a regex tool and it matches abc, axc, a1c — anything.

Search a.c here and it matches a.c.

Every character means itself: dots, asterisks, brackets, plus signs, question marks, backslashes. If you've ever searched for 3.14 and quietly corrupted a 3x14 somewhere in a large document, this is the tool that doesn't do that.

The cost is 3.15 per unit.
The cost is 3.15 per unit.
Subtotal: 3.15 x 100

The cost is  per unit.
The cost is  per unit.
Subtotal:  x 100

The cost is 3.15 per unit.
The cost is 3.15 per unit.
Subtotal: 3.15 x 100

74

74

3

Why literal, and not just "for simplicity"

Two reasons, and the second decided it.

It's what people actually want. If you search for 3.14 you mean 3.14.

A user-supplied pattern is a denial-of-service vector. A regular expression can be crafted to backtrack catastrophically — exponential time on a short input. This runs in your browser, so that would be an attack on the person using the tool, not on a server somewhere.

A literal search is always bounded by the length of the text. It cannot hang the page. That guarantee is why the whole tools engine allows literal replacement and forbids patterns.

The two empty boxes do opposite things

Both deliberate:

An empty replacement is genuinely useful for stripping something out — and it's the easiest way here to do more damage than you meant to, because a search that's slightly too broad deletes a lot very quietly.

An empty search does nothing on purpose. An empty needle would match between every character and insert your replacement into all of those gaps, which nobody has ever wanted.

A search that matched nothing looks exactly like success

The page returns a result either way. This is the failure mode worth guarding against.

Compare the character counts before and after. If they're identical, either nothing matched or your replacement happens to be the same length as your search — so read the result too.

It takes a second, and it's the difference between a bulk edit that worked and one you discover went wrong three days later.

The lines in the result count is the companion check when you're deleting whole entries rather than editing within them — if you removed six lines from a list, that number should have dropped by six. Character counts catch edits; the line count catches deletions.

It replaces everything, and it's case-sensitive

Every occurrence. There's no replace-first or replace-next, because a tool showing you a whole transformed document at once can't meaningfully offer a cursor. If you need to change one instance out of many, a text editor is genuinely better at that job.

Cat will not match cat. That's what you want for identifiers, code and names, and occasionally frustrating in prose.

There's deliberately no case-insensitive option — a case-insensitive replacement has to decide what capitalisation to write back, and that's a judgement about your content that a tool can't make. Run it twice if you need both.

Chained replacements interfere

The classic way a bulk edit goes quietly wrong:

1. Replace A with B
2. Replace B with C

Your original As are now Cs.

Each individual step is correct, which is exactly why it's easy to miss. If any replacement could produce text that a later replacement searches for, route it through a placeholder that appears nowhere else — something like ZZPLACEHOLDERZZ — as an intermediate step.

The printable has a table for planning replacements with a column for interferes with?, which is there because writing them down is what makes the interference visible.

A note on how this one was built

This tool didn't exist for a while, and the reason is worth recording.

A tool on this site is data, never code — a spec names operations from a fixed table, and nothing it supplies gets interpreted. That's what makes a large library of them safe. But the text engine originally handed each pipeline exactly one string, the reader's text, with every other parameter baked in by the author.

Fine for a case converter. Fatal for find-and-replace, where the whole point is that you supply both strings.

So the engine was widened: a step can now bind a parameter to a declared input. The safety story is deliberately the same one the formula parser tells — a binding is looked up in an explicit, prototype-free map of the tool's own declared inputs and resolves to nothing else, and a binding that doesn't name one is a failed build rather than a silently empty parameter.

One real cost came with it. replaceAll now has to bound the work, not just the result: 20,000 single characters each replaced by a 20,000-character string projects to 400 million characters — 800 MB, built and then thrown away, on your machine. It now measures the projection first and stops at the ceiling.

Print the bulk edit checklist — the first item is original saved somewhere, because this is not reversible once you've pasted the result back.