Unicode Space Character List: Code Points and Widths

November 11, 2026 · 12 min read

Unicode Space Characters: Every Space, Code Point and Width

A unicode space character is any character in Unicode's Space_Separator category (Zs). There are 17 of them, from the ordinary U+0020 your space bar types to the em space U+2003 and the ideographic space U+3000. This reference gives each one's code point, width, line-break behaviour and HTML entity, then shows how to type and find them.

What Is the Unicode Space Character U+0020?

U+0020 SPACE is the character your space bar produces. It's ASCII 32, the single byte 20 in UTF-8, and the default word separator in most scripts. When someone asks for the Unicode for space character, U+0020 is almost always the answer.

Space in Unicode covers more than that one character, though. Two lists matter:

  • General category Zs (Space_Separator): 17 characters as of Unicode 18.0, all in the table below.
  • The White_Space property: those 17 plus tab, line feed, vertical tab, form feed, carriage return, next line (U+0085), line separator (U+2028) and paragraph separator (U+2029). That's 25 in all.

PropList.txt in the Unicode Character Database defines White_Space. Programming languages each pick their own set from these lists, and that choice decides what trim() removes and what a regex \s matches.

Unicode Space Character Table: Code Points, Widths and Entities

The widths below come from the annotations in the Unicode code charts, such as the General Punctuation chart. An em equals the font size, so an em space in 16 px text is 16 px wide. The break column follows the Unicode line breaking algorithm (UAX #14).

Code pointNameTypical widthCan a line wrap here?HTML entity
U+0020SpaceSet by the fontYes 
U+00A0No-break spaceSame as U+0020No 
U+1680Ogham space markDrawn as a stroke in many Ogham fontsYes 
U+2000En quadHalf an emYes 
U+2001Em quadOne emYes 
U+2002En spaceHalf an emYes 
U+2003Em spaceOne emYes 
U+2004Three-per-em spaceA third of an emYes 
U+2005Four-per-em spaceA quarter of an emYes 
U+2006Six-per-em spaceA sixth of an emYes 
U+2007Figure spaceWidth of one digitNo 
U+2008Punctuation spaceWidth of a full stopYes 
U+2009Thin space1/5 or 1/6 of an emYes 
U+200AHair space1/10 to 1/16 of an emYes 
U+202FNarrow no-break spaceSame as a thin spaceNo 
U+205FMedium mathematical space4/18 of an emYes 
U+3000Ideographic spaceOne full-width CJK cellYes 

The two quads are canonically equivalent to the en and em spaces, so Unicode normalization (NFC) turns U+2000 into U+2002 and U+2001 into U+2003. Seven rows have no named entity in the WHATWG list of named character references, so you write those as numeric references.

Treat the width column as a target, not a promise. The font decides the real width, and a font that lacks the glyph hands it to a fallback font.

Zero-Width and Blank Characters That Aren't Whitespace

Several characters look like a space, or like nothing, without being in Zs. Most whitespace-stripping code leaves them in place, which makes them hard to catch.

Code pointNameCategoryWhat it's for
U+200BZero width spaceCf (format)Marks a place where a line may wrap, with no width
U+200CZero width non-joinerCfStops two letters from joining, as in Persian
U+200DZero width joinerCfJoins characters, including multi-part emoji
U+2060Word joinerCfForbids a wrap, with no width
U+FEFFZero width no-break spaceCfByte order mark at the start of a file
U+180EMongolian vowel separatorCfWas in Zs until Unicode 6.3.0
U+3164Hangul fillerLo (letter)A blank Hangul letter
U+2800Braille pattern blankSo (symbol)An empty braille cell

Programming languages disagree about these. JavaScript's whitespace rule includes U+FEFF and every Zs character, but not U+200B. Python's str.isspace() checks for Zs or a whitespace bidi class, so it says no to every row in this table:

/\s/.test("\u00A0");   // true, no-break space is whitespace
/\s/.test("\u200B");   // false, zero width space is not
"a\u200B".trim();      // still "a\u200B", length 2
"\u3000".isspace()   # True, ideographic space
"\u200B".isspace()   # False, zero width space
"\u3164".isspace()   # False, Hangul filler

That gap is why U+3164 and U+2800 turn up in blank-name tricks for games and chat apps. A name check usually strips whitespace first, and a letter or symbol survives it.

Which Space Should You Use for Each Job?

Choose a space for what it means rather than how wide it looks:

  • U+00A0 no-break space keeps a number next to its unit, so 10 km never splits across two lines.
  • U+202F narrow no-break space is the thin, unbreakable gap French typography places before ; ! and ?, while a colon traditionally takes a full no-break space. The French number format in Unicode's CLDR data also groups thousands with it.
  • U+2009 thin space adds a sliver of air around a slash or an en dash. Lines can still wrap at it.
  • U+2007 figure space is exactly one digit wide, so it pads short numbers in a column when the font has tabular digits.
  • U+3000 ideographic space matches the width of a Chinese, Japanese or Korean character, so CJK text uses it in place of U+0020.
  • U+200B zero width space gives a long URL or compound word a spot to wrap without showing a gap. In HTML, the <wbr> element does the same job.

We prefer CSS for spacing that only serves the layout. A margin or letter-spacing value adapts when the design changes, while a row of em spaces stays frozen in the text.

How Do I Enter a Unicode Space Character?

Every method below starts from the hex code point, so 2009 gets you a thin space:

  • Word for Windows: type 2009, then press Alt+X. Word replaces the code with the character.
  • macOS: add Unicode Hex Input under Input Sources in Keyboard settings and switch to it. Then hold Option while you type the four hex digits.
  • Linux with GNOME: press Ctrl+Shift+U, type 2009, then press Space or Enter.
  • HTML: &#x2009;, or the named entity from the table above.
  • CSS: content: "\2009"; inside a ::before or ::after rule.
  • JavaScript and JSON: the escape "\u2009" in a string.
  • Python: "\u2009", or the more readable "\N{THIN SPACE}".

In code and config files, use the escape rather than the raw character, so anyone auditing the file later knows which space you meant.

What Is a Symbol for Space?

To show a space rather than insert one, say in a typing exercise, use a visible stand-in:

  • ␣ U+2423 OPEN BOX: the chart notes describe it as a graphic for space. HTML even has a named entity for it, &blank;.
  • ␠ U+2420 SYMBOL FOR SPACE: a small SP from the Control Pictures block, which has a picture for each ASCII control code.
  • · U+00B7 MIDDLE DOT: the marker many code editors draw for each space when you turn on visible whitespace. It's one of many look-alike Unicode dot characters.

Use them in explanations only. A reader who copies a command containing ␣ gets the box, not a space.

How Unicode Spaces Behave in Markdown

The CommonMark spec treats almost all of these characters as ordinary text. Three rules are the exception:

  1. Only U+0020 creates a hard line break. Two trailing spaces end a line, but two trailing no-break spaces are just text. Our Markdown line break guide covers the other ways to break a line.
  2. Only spaces and tabs count as indentation. Four em spaces at the start of a line don't open a code block. The Markdown indentation guide shows the methods that do work.
  3. Emphasis looks at Unicode whitespace. The spec defines it as any Zs character plus tab, line feed, form feed and carriage return. A ** followed by one of those can't open bold text.

Rule 3 bites when you paste from a word processor. If a raw em space sits right after the opening **, you get literal asterisks. A raw zero width space in the same spot doesn't stop the bold, because U+200B is a format character, not Zs. Writing the entity, as in **&emsp;bold**, also works, since the parser sees an ampersand there.

Entities are the safe way to put special spaces in Markdown, because they're visible in the source:

Q1&emsp;Q2&emsp;Q3
A&hairsp;B A&thinsp;B A&ensp;B A&emsp;B

The first line renders as three labels separated by em-wide gaps. The second shows four A and B pairs, each gap wider than the last. To print an entity as literal text instead, escape its ampersand, as our guide to escaping Markdown characters shows. Edit the width ladder below:

Unicode space widths

A B hair space U+200A
A B thin space U+2009
A B normal space U+0020
A B en space U+2002
A B em space U+2003
A B ideographic space U+3000
A​B zero width space U+200B

Widths depend on the font you view this in.

42 words269 characters11 lines
Markdown

Each entity turns into its character in the preview, so you can compare the gaps. Paste the raw characters instead and the source gives you no clue which space is which.

Finding Invisible Spaces in Your Text

Typical symptoms are a search that misses an obvious match or two strings that look equal but compare unequal. Three checks find the culprit.

List every one by code point. This Python script prints the line, column and code point of each suspicious character in a UTF-8 file:

import re, sys

pattern = re.compile(r"[\u00A0\u1680\u180E\u2000-\u200B\u202F\u205F\u2060\u2800\u3000\u3164\uFEFF]")

with open(sys.argv[1], encoding="utf-8") as f:
    for n, line in enumerate(f, 1):
        for m in pattern.finditer(line):
            print(f"line {n}, col {m.start() + 1}: U+{ord(m.group()):04X}")

Run it as python3 find_spaces.py notes.md to get lines like line 3, col 1: U+3000. It skips U+200C and U+200D on purpose, because emoji sequences and some scripts need them.

Diff against a clean copy. Paste the suspect text and a retyped version into the text compare tool. Set Compare by to characters and leave Ignore whitespace off, since that option trims each line and would hide a trailing no-break space. A highlighted gap that looks the same on both sides is your invisible character. Our guide to comparing two texts lists other invisible differences, such as line endings and byte order marks.

Lint the Markdown. The Markdown linter runs markdownlint, whose MD009 rule flags whitespace at the end of a line. MD009 uses JavaScript's trimEnd(), so it catches a trailing no-break or em space but not a trailing zero width space.

The linter has a blind spot, though. MD009 allows exactly two trailing characters by default, for hard breaks, so a pair of trailing no-break spaces slips through. No built-in markdownlint rule flags a no-break or zero width space in the middle of a line.

Every unicode space character has a job: glue a unit, pad a digit, fit CJK text or mark a hidden wrap point. Pick the one whose meaning fits, write it as an entity or escape so it stays visible, and run the detection script when text misbehaves. To compare entity spaces side by side, paste your sample into the free Markdown editor and watch the live preview.