Braille Patterns

Unicode Braille Patterns

The Unicode Braille Patterns block (U+2800–U+28FF) contains 256 characters representing all possible dot combinations in a 2×4 Braille cell. These characters allow Braille text to be represented in plain Unicode, enabling digital transmission and display of Braille without specialized formats.

Braille Cell Structure

A standard Braille cell consists of six dots arranged in a 2-column, 3-row grid (dots 1–6). Grade 1 Braille uses one cell per letter; Grade 2 uses contractions. Unicode also encodes 8-dot Braille (adding dots 7 and 8 at the bottom), providing 256 possible patterns.

Dot numbering:

Dot positions:  Column 1  Column 2
  Row 1:          1          4
  Row 2:          2          5
  Row 3:          3          6
  Row 4 (8-dot):  7          8

Code Point Structure

The 8 bits of the code point offset from U+2800 correspond directly to the 8 dots:

U+2800 + bit mask = code point

Bit 0 (value 1)   → Dot 1
Bit 1 (value 2)   → Dot 2
Bit 2 (value 4)   → Dot 3
Bit 3 (value 8)   → Dot 4
Bit 4 (value 16)  → Dot 5
Bit 5 (value 32)  → Dot 6
Bit 6 (value 64)  → Dot 7
Bit 7 (value 128) → Dot 8

Examples:

# U+2800 = blank cell (no dots)
# U+2801 = dot 1 only (bit 0 set)
# U+2803 = dots 1,2 (bits 0,1 set)
# U+2809 = dots 1,4 (bits 0,3 set)

chr(0x2800)  # ⠀ (blank)
chr(0x2801)  # ⠁ (dot 1)
chr(0x2803)  # ⠃ (dots 1,2)
chr(0x28FF)  # ⣿ (all 8 dots)

Computing Braille Code Points

def braille_char(dots: list[int]) -> str:
    offset = 0
    for dot in dots:
        # Map dot numbers to bit positions
        bit_positions = {1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7}
        offset |= (1 << bit_positions[dot])
    return chr(0x2800 + offset)

braille_char([1, 2])     # ⠃ (U+2803)
braille_char([1, 4, 5])  # ⠙ (U+2819)

# Decompose a Braille character into its dots
def braille_dots(char: str) -> list[int]:
    offset = ord(char) - 0x2800
    bit_to_dot = {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8}
    return [bit_to_dot[i] for i in range(8) if offset & (1 << i)]

braille_dots('⠙')  # [1, 4, 5]

Unicode Braille vs. Standard Braille

Unicode Braille is a direct encoding of dot patterns, independent of any specific Braille code system. Different Braille standards (English Grade 1/2, Unified English Braille, French Braille, etc.) map characters to dot patterns differently. A program using Unicode Braille must know which standard to apply for meaningful text.

Refreshable Braille Displays

Hardware Braille displays (refreshable Braille displays) receive Unicode Braille via a screen reader's Braille translation layer. The screen reader converts standard Unicode text (e.g., "Hello") to Braille cells according to the user's language and grade settings, then sends the Braille Unicode characters to the display.

Artistic and Technical Uses

Braille Pattern characters have found creative uses beyond accessibility:

# Terminal block graphics using Braille patterns
# Each Braille cell covers a 2×4 pixel area, enabling
# high-resolution terminal art
def pixel_to_braille(pixels):
    '''
    pixels: 2x4 boolean grid
    Returns a single Braille character
    '''
    dot_map = [(0,0,1), (0,1,2), (0,2,3), (1,0,4),
               (1,1,5), (1,2,6), (0,3,7), (1,3,8)]
    dots = [dot for col, row, dot in dot_map if pixels[row][col]]
    return braille_char(dots)

This technique is used in terminal graphing utilities to render curves and graphs at 2× horizontal and 4× vertical resolution compared to block characters.