Em dash replacer, run locally

One global substitution over the pasted string. The pattern is a character class holding two codepoints, U+2014 and U+2013, and every match is replaced with the string in the single text control. There is no tokenisation, no sentence parsing and no grammatical inspection, which is worth stating because at least one competing page advertises conversion to grammatically correct commas. A substitution of this shape cannot read grammar.

The control is a text input rather than a select, and that accounts for most of the practical difference between this em dash replacer and the ranking alternatives, which ship fixed menus of four to six presets. Any string is a valid replacement, so a double hyphen, a comma followed by a space or a spaced hyphen need no special support because they are not special cases.

Execution is client-side. No request is made, which is why no run allowance and no character ceiling apply here. The input pane is not mutated by a run, so successive runs with different replacements all operate on the original text.

The default configuration, a hyphen, handles the common case without any change.

Step 1

Paste the source text into the input pane. A live character and word count sits above it.

Step 2

Set the replacement field, pre-filled with a hyphen. An empty field resolves to a hyphen, not an empty string.

Step 3

Execute. The rewritten text appears in the read-only output pane with a copy control above it.

U+2014 is the em dash. U+2013 is the en dash, conventionally used for ranges and spans. Both sit inside the class, so both are rewritten in the same pass. That is broader coverage than one of the better-known replacer pages offers at all, and a second competitor exposes it only as an opt-in checkbox beside its smart quote handling.

Everything else stays intact. U+002D, the ordinary hyphen-minus, is not matched, and neither is a double hyphen, because the class contains no hyphen. Figure dashes, horizontal bars and the other dash-like characters in Unicode are not in the class either: if your source contains one, this pass leaves it where it is.

Breadth and precision trade against each other here. One class means one replacement string for both widths, with no mechanism to map U+2014 to a comma while mapping U+2013 to a hyphen. Where the two carry genuinely different meanings, sequence two passes with the find and replace route.

The hyphen is a single byte in ASCII and therefore in UTF-8. U+2014 encodes to three bytes. Every stage that touches the text must read those three bytes as one character, and a stage assuming a single-byte encoding renders them as two or three unrelated glyphs. That is the mechanism behind the familiar symptom of one mangled dash in an otherwise readable import.

The operational rule follows from the encoding rather than from taste. Where text is consumed by a program rather than a reader, restrict it to characters that cannot be misread: configuration values, URL slugs, CSV exports, database fields and API payloads all belong in that category.

The same reasoning explains why the substitution runs toward the hyphen rather than away from it. A hyphen is safe in every encoding any stage might guess at. A long dash is safe only when every stage agrees.

Deleting the character removes both the tell and the punctuation. Where the dash carried grammatical load, marking an aside or separating two independent clauses, deletion produces a run-together sentence a reader notices more than the dash ever was. Substitution preserves the structural break and changes only the mark that signals it.

Deletion still wins in one case: where the dash sits between spaces that already do the separating work, so removing it leaves a double space for a whitespace pass to collapse. That is the em dash remover route, which deletes U+2014 and does not touch U+2013. Decide by asking whether the sentence still parses with no mark at that position.

A third option this tool deliberately does not implement is wrapping, turning a pair of dashes into an opening and a closing parenthesis. That needs dashes matched in pairs with a different character at each end. This pass emits an identical string at every match, so paired wrapping is out of reach and is claimed nowhere.

The substitution is the entire operation. Nothing runs before it and nothing after it, which produces four behaviours worth knowing before the first run.

No spacing normalisation

Surrounding whitespace is untouched, so a spaced dash replaced by a comma leaves a space before the comma. Encode the spacing into the replacement.

No count in the summary

The footer reports characters removed as a length difference. A one-for-one swap removes none, so it reports completion. Verify against the output pane.

No undo control

None is needed: the input pane is never rewritten, so adjust the replacement and execute again.

No adjacent clean-up

Curly quotes, the ellipsis character, non-breaking spaces and zero-width characters are outside this route. A separate scanner covers 14 invisible codepoints.

No detector outcome is predicted here and none is guaranteed. Detection systems report statistical signals over a sample of text and cannot establish authorship. A page selling punctuation substitution as a route past them is selling what it cannot deliver.

The defensible statement is about frequency. Models emit U+2014 at a rate well above ordinary unedited human writing, often several times in a paragraph, and it is the density rather than the presence of the character that a reader registers. Substituting it removes that one surface pattern. Sentence length distribution, clause structure and lexical choice are unchanged by a character-level pass, and they carry far more signal than punctuation does.

Two groups, same requirement, different reasons. Editorial users are conforming a draft to a house style, or removing a pattern that reads as machine-written before anyone else sees it. Technical users are sanitising prose before it enters a store that will not round-trip a three-byte character.

Locality unites them. Unpublished copy, client work under an agreement, internal documentation and seed data are all text people would rather not paste into a remote service to fix one punctuation mark. This route makes no network request, so what a server retains is not a question, and there is no allowance to spend on a job this small.