Control Character Remover

Logs are supposed to be plain text, but the world does not always cooperate. Binary payloads leak into text streams, terminal captures drag in escape and control bytes, Windows files carry carriage returns, and sloppy writers emit form feeds, backspaces, and NULs that look like nothing on screen and break everything downstream. Control Character Remover cleans all of that up in one click, entirely in your browser.

Every ASCII control byte from NUL (0x00) through US (0x1F) is handled by default, minus whichever of tab, newline, and carriage return you choose to keep, plus DEL (0x7F) and the C1 range (0x80 — 0x9F) when you switch those options on. The tool scans the input one character at a time and removes or neutralizes those bytes while preserving the whitespace that actually structures your log: tabs, newlines, and carriage returns stay by default and each can be kept or stripped independently with its own checkbox, so you can, for example, keep newlines but strip stray carriage returns to normalize a Windows-authored file to Unix line endings. What you get back is a log a parser can read, a shipper can accept, and a database can store without choking on an unexpected byte.

When you need to know exactly what was cleaned, switch on caret notation and every removed byte is replaced with a printable marker instead of silently vanishing. C0 controls and DEL get standard caret notation — ^A for 0x01, ^M for a stray carriage return, ^[ for a lone ESC byte, ^? for DEL — the same convention terminals and editors have used for decades. C1 control bytes (0x80—0x9F) do not have a standard caret form, so instead of collapsing every one of them into the same ambiguous symbol, each is shown as its own hex escape like \x85, so two different C1 bytes never look identical in the output. The summary cards report the exact number of control bytes removed and the byte size before and after (measured in real UTF-8 bytes, not character count), confirming the log is really clean — or, in caret mode, showing you honestly that the output grew because every removed byte was replaced by a two-to-four character marker.

• Full C0 coverage — removes NUL through US (0x00 — 0x1F) except whatever whitespace you choose to keep.
• Optional DEL removal — strip the 0x7F delete byte when it is present, off by default.
• Optional C1 control removal — clean the 0x80—0x9F range some legacy tools still emit, off by default.
• Whitespace control — keep or strip tab, newline, and carriage return independently, so you can normalize line endings without losing structure.
• Caret notation mode — show removed C0/DEL bytes as standard ^X markers and C1 bytes as distinct \xNN hex escapes, so nothing collapses into an ambiguous symbol.
• Byte stats — controls removed and byte savings (or growth, in caret mode), measured in real UTF-8 bytes.
• Copy / Download TXT / Print — take the clean log with you in whatever form the next step needs.
• 100% local — nothing leaves the browser.

1. Paste your log into the text box — control characters and all, no need to pre-clean anything.
2. Set preservation. Choose whether to keep tab, newline, and carriage return; all three are kept by default since they are what actually structure a log file.
3. Choose scope. Turn on Remove DEL and Remove C1 controls if your data carries those less common bytes.
4. Pick output style. Leave caret notation off to remove the bytes outright, or turn it on to see exactly which byte was where — standard ^X markers for C0/DEL, \xNN hex escapes for C1.
5. Run. The stats report exactly how many control bytes were removed and the byte-size change.
6. Copy, download, or print the clean result and hand it to the next step in your pipeline.

Example 1 — Binary leak. A message queue log has NUL bytes wedged between every field. Run the tool with defaults and the NULs disappear entirely, leaving readable key=value text that parses cleanly with any standard log parser.

Example 2 — Windows line endings. A file uses CR+LF pairs throughout; with Preserve newline on and Preserve carriage return off, the stray carriage returns are stripped one at a time while every newline survives, normalizing the file to clean Unix line endings.

Example 3 — Terminal capture. A screen capture includes bell (0x07) and form-feed (0x0C) characters scattered through it; caret mode shows ^G and ^L exactly where they were, so you can audit the cleanup and confirm nothing important was silently deleted before sharing the file.

Example 4 — Mixed C1 bytes. A log carries two different C1 control bytes, 0x85 and 0x8D, sitting a few characters apart. With Remove C1 controls and caret notation both on, the output shows \x85 and \x8D as distinct markers instead of two identical, uninformative ^? symbols, so you can tell they were different bytes.

• Parsable output — strip hidden bytes, keep the structure and whitespace you choose.
• Auditable — caret notation shows every removal with a marker specific to that byte, C0/DEL and C1 alike.
• Granular — control exactly which whitespace survives and which byte ranges get cleaned.
• Instant — one click, fully local, no upload wait.
• Private — nothing leaves the browser, ever.