Why do hyphens pop up mid-word after I paste text?

The text you copied had soft hyphens, and the app you pasted into draws each one as a visible hyphen instead of hiding it, so accessibility shows up as ac-ces-si-bil-i-ty. Searching for - won't find them, because the character underneath is still U+00AD. Remove that code point instead, for example with `text.replace(/\u00AD/g, '')` in JavaScript.

Why is there a stray Â in the middle of words?

Your UTF-8 text contains soft hyphens, stored as C2 AD, and it's being read as Windows-1252. The C2 becomes a visible Â, while AD is the soft hyphen itself and stays hidden, so the Â seems to come from nowhere. If nginx serves the page, add `charset utf-8;` to the server block so the browser stops guessing.

How do I find soft hyphens I can't see?

Search by code point, since there's nothing to look at. With regex turned on in VS Code's find box, `\u00AD` matches every one. In Python, `text.find('\u00ad')` returns the position of the first one, or -1 if there are none.

Why does show up as literal text in React?

Because it's inside a JavaScript string, and React escapes strings instead of decoding HTML entities in them. Entities only work in JSX text written directly between tags. In a string, use the escape `\u00AD` instead, as in `'Versicherungs\u00ADgesellschaft'`, and React renders a real soft hyphen.

Why doesn't CLEAN or TRIM remove soft hyphens in Excel?

CLEAN only strips the control codes 0 to 31, and TRIM only handles regular spaces, so U+00AD survives both. Remove it by code point with `=SUBSTITUTE(A1, UNICHAR(173), "")`, and do it on imported columns before you use them as lookup keys.

Why did every ¡ disappear from my old DOS text?

It didn't, it's just invisible. The file uses a DOS code page, where ¡ is byte 173, and whatever opened it reads Windows-1252, where 173 is the soft hyphen. So ¡Qué bien! looks like Qué bien! but still holds the byte. Decode it properly and the marks come back: in Python, `Path('old.txt').read_text(encoding='cp850')`.

ASCII 173

Soft hyphenInverted exclamation mark

ASCII 173 is a soft hyphen on Windows and ¡ in old DOS.

SHY (Soft Hyphen) is byte 173 in Windows-1252, Unicode U+00AD. It marks a spot where a word may be hyphenated. It stays invisible unless the line actually breaks there, and then a hyphen appears, which helps long German compounds like Donaudampfschiff fit narrow columns. The catch is that it's still a character. Copy a product name off a page that uses it and the pasted text can carry a hidden U+00AD, so it fails an exact database match or a string comparison while looking identical. Strip U+00AD from user input before comparing. For new pages, CSS hyphens: auto plus a lang attribute does the same job without touching the text. In UTF-8 it's C2 AD, and the HTML entity is .

¡ (Inverted Exclamation Mark) is byte 173 in code page 437, the original IBM PC character set, and maps to Unicode U+00A1. Windows-1252 has the invisible soft hyphen at 173, so Spanish DOS text read as Windows-1252 loses every ¡ without a trace: ¡Hola! becomes Hola!. Code page 850 kept ¡ at 173 too.

PunctuationPunctuation

Technical Details

Code Example

</>

#include <stdio.h>

int main(void) {
    /* On Windows (code page 1252) byte 173 is soft hyphen.
       Modern terminals expect UTF-8, so print the code point, not the byte. */
    printf("\u00AD\n");   /* UTF-8: C2 AD */

    unsigned char b = 173;         /* the raw Windows-1252 byte */
    printf("%d 0x%02X\n", b, b);    /* 173 0xAD */
    return 0;
}

Code Example

</>

#include <stdio.h>

int main(void) {
    /* Byte 173 is ¡ only on a console using code page 437
       (chcp 437 on Windows, or DOSBox). On a UTF-8 terminal the
       lone byte 0xAD is invalid and prints as garbage, often �. */
    putchar(173);

    /* char is signed on x86, so a plain char holding 0xAD is -83.
       Use unsigned char when you compare or index by byte value. */
    char c = (char)173;
    unsigned char u = 173;
    printf("\n%d %d\n", c, u);   /* -83 173 */

    /* Portable: print the Unicode character as UTF-8 instead. */
    printf("\u00A1\n");          /* C2 A1 */
    return 0;
}

How to Type It

Windows: Hold Alt and type 0173 on the numeric keypad, with Num Lock on. The leading zero picks the Windows code page. No numeric keypad? In Word, type 00AD and press Alt+X.
Mac: Press Control+Command+Space to open the Character Viewer, then search for "soft hyphen". It stays invisible unless a line breaks at it.
Linux: In GNOME, or any desktop running IBus, press Ctrl+Shift+U, type ad, then Space. With a Compose key set up, press Compose, minus, minus, space.
Phone: Phone keyboards have no key for it. Tap the character at the top of this page to copy it.

How to Type It

Windows: Hold Alt and type 173 on the numeric keypad, with no leading zero. Windows reads it as a DOS code and inserts ¡.

¡ is also ASCII 161 on Windows, which has the full guide.

Frequently Asked Questions

The text you copied had soft hyphens, and the app you pasted into draws each one as a visible hyphen instead of hiding it, so accessibility shows up as ac-ces-si-bil-i-ty. Searching for - won't find them, because the character underneath is still U+00AD. Remove that code point instead, for example with `text.replace(/\u00AD/g, '')` in JavaScript.
Your UTF-8 text contains soft hyphens, stored as C2 AD, and it's being read as Windows-1252. The C2 becomes a visible Â, while AD is the soft hyphen itself and stays hidden, so the Â seems to come from nowhere. If nginx serves the page, add `charset utf-8;` to the server block so the browser stops guessing.
Search by code point, since there's nothing to look at. With regex turned on in VS Code's find box, `\u00AD` matches every one. In Python, `text.find('\u00ad')` returns the position of the first one, or -1 if there are none.
Because it's inside a JavaScript string, and React escapes strings instead of decoding HTML entities in them. Entities only work in JSX text written directly between tags. In a string, use the escape `\u00AD` instead, as in `'Versicherungs\u00ADgesellschaft'`, and React renders a real soft hyphen.
CLEAN only strips the control codes 0 to 31, and TRIM only handles regular spaces, so U+00AD survives both. Remove it by code point with `=SUBSTITUTE(A1, UNICHAR(173), "")`, and do it on imported columns before you use them as lookup keys.
It didn't, it's just invisible. The file uses a DOS code page, where ¡ is byte 173, and whatever opened it reads Windows-1252, where 173 is the soft hyphen. So ¡Qué bien! looks like Qué bien! but still holds the byte. Decode it properly and the marks come back: in Python, `Path('old.txt').read_text(encoding='cp850')`.

Frequently Asked Questions

It didn't, it's just invisible. The file uses a DOS code page, where ¡ is byte 173, and whatever opened it reads Windows-1252, where 173 is the soft hyphen. So ¡Qué bien! looks like Qué bien! but still holds the byte. Decode it properly and the marks come back: in Python, `Path('old.txt').read_text(encoding='cp850')`.

ASCII 173

Soft hyphenInverted exclamation mark

ASCII 173 is a soft hyphen on Windows and ¡ in old DOS.

Punctuation

#include <stdio.h>

int main(void) {

/* On Windows (code page 1252) byte 173 is soft hyphen.

Modern terminals expect UTF-8, so print the code point, not the byte. */

printf("\u00AD\n"); /* UTF-8: C2 AD */

unsigned char b = 173; /* the raw Windows-1252 byte */

printf("%d 0x%02X\n", b, b); /* 173 0xAD */

return 0;

}

#include <stdio.h>

int main(void) {

/* Byte 173 is ¡ only on a console using code page 437

(chcp 437 on Windows, or DOSBox). On a UTF-8 terminal the

lone byte 0xAD is invalid and prints as garbage, often �. */

putchar(173);

/* char is signed on x86, so a plain char holding 0xAD is -83.

Use unsigned char when you compare or index by byte value. */

char c = (char)173;

unsigned char u = 173;

printf("\n%d %d\n", c, u); /* -83 173 */

/* Portable: print the Unicode character as UTF-8 instead. */

printf("\u00A1\n"); /* C2 A1 */

return 0;

}