Braille Pattern Characters

The Unicode Braille Patterns block (U+2800--U+28FF) encodes all 256 possible combinations of the eight-dot braille cell, creating a complete digital representation of the braille writing system used by millions of visually impaired people worldwide. Unlike most Unicode blocks that encode specific characters with fixed meanings, the Braille Patterns block encodes the dot patterns themselves -- the meaning of each pattern depends on the braille code being used (English Braille, French Braille, Japanese Braille, etc.). This guide explains how Unicode braille works, how the encoding maps to physical dot positions, and how these characters serve accessibility and beyond.

How Braille Works

The Braille Cell

Braille is a tactile writing system invented by Louis Braille in 1824. Each braille character is a cell containing up to six or eight raised dots arranged in a grid:

6-dot cell:        8-dot cell:
 1 4                1 4
 2 5                2 5
 3 6                3 6
                    7 8

The six-dot cell (the original system) provides 64 possible combinations (2^6 = 64), including the empty cell. The eight-dot cell (used in computer braille and some modern systems) provides 256 combinations (2^8 = 256).

Dots are numbered by column, top to bottom: dots 1-2-3 form the left column, dots 4-5-6 form the right column, and dots 7-8 (in 8-dot braille) form the bottom row.

Braille Grades

English Braille has two main grades:

Grade 2 is the standard for published braille in English-speaking countries. It uses approximately 180 contractions and short-form words to reduce the bulk of braille text, which is important because braille takes significantly more physical space than print.

Unicode Braille Encoding

The Block: U+2800--U+28FF

Unicode encodes braille as abstract dot patterns, not as letters or words. Each of the 256 code points represents one specific combination of raised dots in an 8-dot cell.

The encoding uses a binary mapping where each dot position corresponds to a bit:

The code point for any braille pattern is:

U+2800 + (sum of bit values for raised dots)

Examples

The empty braille pattern U+2800 (BRAILLE PATTERN BLANK) is notable -- it represents a braille cell with no raised dots and functions as a braille space character.

English Braille Alphabet

The first ten letters of Grade 1 English Braille use dots 1-2-4-5 only (the top four positions):

Letters k--t add dot 3 to the a--j patterns. Letters u--z (except w) add dots 3 and 6. The letter w (⠺, dots 2-4-5-6) breaks the pattern because the original French alphabet did not include w -- Louis Braille was French, and w was added later.

Working with Braille in Code

Python: Text to Braille

# Grade 1 English Braille mapping (lowercase a-z)
BRAILLE_ALPHA = {
    "a": "\u2801", "b": "\u2803", "c": "\u2809", "d": "\u2819",
    "e": "\u2811", "f": "\u280B", "g": "\u281B", "h": "\u2813",
    "i": "\u280A", "j": "\u281A", "k": "\u2805", "l": "\u2807",
    "m": "\u280D", "n": "\u281D", "o": "\u2815", "p": "\u280F",
    "q": "\u281F", "r": "\u2817", "s": "\u280E", "t": "\u281E",
    "u": "\u2825", "v": "\u2827", "w": "\u283A", "x": "\u282D",
    "y": "\u283D", "z": "\u2835", " ": "\u2800",
}

def text_to_braille(text):
    return "".join(BRAILLE_ALPHA.get(c, c) for c in text.lower())

print(text_to_braille("hello world"))
# ⠓⠑⠇⠇⠕⠀⠺⠕⠗⠇⠙

Python: Dot Pattern Calculation

def dots_to_braille(*dots):
    # Convert dot numbers (1-8) to a braille character
    bit_map = {1: 0x01, 2: 0x02, 3: 0x04, 4: 0x08,
               5: 0x10, 6: 0x20, 7: 0x40, 8: 0x80}
    value = sum(bit_map[d] for d in dots)
    return chr(0x2800 + value)

def braille_to_dots(char):
    # Convert a braille character to its dot numbers
    offset = ord(char) - 0x2800
    bit_map = {0x01: 1, 0x02: 2, 0x04: 3, 0x08: 4,
               0x10: 5, 0x20: 6, 0x40: 7, 0x80: 8}
    return [dot for bit, dot in sorted(bit_map.items()) if offset & bit]

print(dots_to_braille(1, 2, 4))  # ⠋ (letter f)
print(braille_to_dots("⠋"))      # [1, 2, 4]

JavaScript: Braille Encoder

function dotsToBraille(...dots) {
    const bitMap = {1:0x01, 2:0x02, 3:0x04, 4:0x08,
                    5:0x10, 6:0x20, 7:0x40, 8:0x80};
    const value = dots.reduce((sum, d) => sum + bitMap[d], 0);
    return String.fromCodePoint(0x2800 + value);
}

console.log(dotsToBraille(1, 2, 4)); // ⠋

Braille Art

The 256 braille patterns have been repurposed as a pixel-art medium. Because each 8-dot braille cell can represent a 2x4 grid of on/off dots, braille characters can render low-resolution images in plain text terminals. Libraries like Python's drawille use this technique:

# Each braille character is a 2-wide x 4-tall pixel block
# Full block: dots 1-2-3-4-5-6-7-8 = U+28FF = ⣿
# This creates text-art with 2x4 subpixel resolution

# Example: a simple horizontal line
line = "\u28FF" * 20  # 20 full blocks = 40 pixels wide
print(line)
# ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿

This "braille art" technique is popular in terminal dashboards (like asciimatics and blessed) for rendering graphs, charts, and even images at higher resolution than traditional block characters allow.

Accessibility Considerations

Screen Readers and Braille Displays

Unicode braille characters interact with assistive technology in important ways:

1. Refreshable braille displays can render Unicode braille patterns directly by raising the physical dots that correspond to each character's bit pattern.

2. Screen readers may read Unicode braille characters as their dot numbers (e.g., "dots 1-2-4") rather than their Grade 2 English interpretation. This is because the Unicode characters represent patterns, not letters -- the mapping from pattern to letter depends on the braille code and context.

3. Braille translation software (like JAWS, NVDA, or LibLouis) performs the actual translation between print text and braille. These tools work at a higher level than Unicode code points.

When to Use Unicode Braille

Important Caveat

Unicode braille characters are visual representations of braille cells. They are not a replacement for proper braille translation. Converting English text to Unicode braille using a simple letter-by-letter lookup (as in the code example above) produces Grade 1 braille, which is not the standard for published material. Proper Grade 2 translation requires handling hundreds of contraction rules and is best done by dedicated braille translation libraries like LibLouis.

The Full 256-Pattern Grid

The complete set of 8-dot braille patterns forms a 16x16 grid when arranged by code point:

U+2800: ⠀⠁⠂⠃⠄⠅⠆⠇⠈⠉⠊⠋⠌⠍⠎⠏
U+2810: ⠐⠑⠒⠓⠔⠕⠖⠗⠘⠙⠚⠛⠜⠝⠞⠟
U+2820: ⠠⠡⠢⠣⠤⠥⠦⠧⠨⠩⠪⠫⠬⠭⠮⠯
U+2830: ⠰⠱⠲⠳⠴⠵⠶⠷⠸⠹⠺⠻⠼⠽⠾⠿
U+2840: ⡀⡁⡂⡃⡄⡅⡆⡇⡈⡉⡊⡋⡌⡍⡎⡏
U+2850: ⡐⡑⡒⡓⡔⡕⡖⡗⡘⡙⡚⡛⡜⡝⡞⡟
U+2860: ⡠⡡⡢⡣⡤⡥⡦⡧⡨⡩⡪⡫⡬⡭⡮⡯
U+2870: ⡰⡱⡲⡳⡴⡵⡶⡷⡸⡹⡺⡻⡼⡽⡾⡿
U+2880: ⢀⢁⢂⢃⢄⢅⢆⢇⢈⢉⢊⢋⢌⢍⢎⢏
U+2890: ⢐⢑⢒⢓⢔⢕⢖⢗⢘⢙⢚⢛⢜⢝⢞⢟
U+28A0: ⢠⢡⢢⢣⢤⢥⢦⢧⢨⢩⢪⢫⢬⢭⢮⢯
U+28B0: ⢰⢱⢲⢳⢴⢵⢶⢷⢸⢹⢺⢻⢼⢽⢾⢿
U+28C0: ⣀⣁⣂⣃⣄⣅⣆⣇⣈⣉⣊⣋⣌⣍⣎⣏
U+28D0: ⣐⣑⣒⣓⣔⣕⣖⣗⣘⣙⣚⣛⣜⣝⣞⣟
U+28E0: ⣠⣡⣢⣣⣤⣥⣦⣧⣨⣩⣪⣫⣬⣭⣮⣯
U+28F0: ⣰⣱⣲⣳⣴⣵⣶⣷⣸⣹⣺⣻⣼⣽⣾⣿

This grid demonstrates the binary encoding: the first 64 characters (U+2800--U+283F) cover all 6-dot patterns, and the remaining 192 add dots 7 and 8 in all combinations.

Unicode braille patterns serve as a bridge between the tactile world of braille literacy and the digital world of text processing. Whether used for accessibility, education, terminal art, or data visualization, these 256 characters encode a complete writing system in a mathematically elegant binary framework.