Braille

Contents

Characters A-Z All 64 6-dot Braille Unicode characters All 256 8-dot Braille Unicode characters Braille for representing numbers Links Author's View

Characters A-Z

Notes: A-J form the base characters, and K-Z (except W) can be formed by adding dots to them: K-T: A-J plus 1 dot U-V and X-Z (excluding W): A-E plus 2 dots 'ejoty' gives every 5th char.

All 64 6-dot Braille Unicode characters

Mnemonics: 'corners' are even numbers, in anticlockwise order: f/6⠋⠙d/4 h/8⠓⠚j/0 mirror images: ⠑⠊ e/i (vowels) (e starts with dot 1, i starts with dot 2, i.e. small letter with small number) mirror images: ⠗⠺ r/w (right/wrong) (right/west) similar: ⠇⠗ l/r (left/right) similar: ⠕⠗ o/r ('or') similar: ⠕⠵ o/z ('Oz') similar: ⠧⠼ v/number similar: ⠛⠭ g/x contain dot 1: A-H K-R U-Z (excluding W) don't contain dot 1: I&J S&T W vowels: ⠁⠑⠊⠕⠥ aeiou 26 letters: ⠁⠃⠉⠙⠑⠋⠛⠓⠊⠚⠅⠇⠍⠝⠕⠏⠟⠗⠎⠞⠥⠧⠺⠭⠽⠵ abcdefghijklmnopqrstuvwxyz

All 256 8-dot Braille Unicode characters

There are 256 Braille Unicode characters: U+2800..U+28FF (10240..10495). The final column is useful for sorting the chars as though they are the binary representation of integers. Note: the char '*' has a lower Unicode codepoint than '1', thus sorting as a string, sorts them in numerical order.

Braille for representing numbers

Braille typically numbers dots 1 2 3 7 (left) 4 5 6 8 (right). However, if we use numbering 1 2 3 4 5 6 7 8, then Braille dots can be used as the binary representation for the numbers 0 to 255 inclusive. The 256 Braille chars ordered by binary representation: ⠀⢀⠠⢠⠐⢐⠰⢰⠈⢈⠨⢨⠘⢘⠸⢸ ⡀⣀⡠⣠⡐⣐⡰⣰⡈⣈⡨⣨⡘⣘⡸⣸ ⠄⢄⠤⢤⠔⢔⠴⢴⠌⢌⠬⢬⠜⢜⠼⢼ ⡄⣄⡤⣤⡔⣔⡴⣴⡌⣌⡬⣬⡜⣜⡼⣼ ⠂⢂⠢⢢⠒⢒⠲⢲⠊⢊⠪⢪⠚⢚⠺⢺ ⡂⣂⡢⣢⡒⣒⡲⣲⡊⣊⡪⣪⡚⣚⡺⣺ ⠆⢆⠦⢦⠖⢖⠶⢶⠎⢎⠮⢮⠞⢞⠾⢾ ⡆⣆⡦⣦⡖⣖⡶⣶⡎⣎⡮⣮⡞⣞⡾⣾ ⠁⢁⠡⢡⠑⢑⠱⢱⠉⢉⠩⢩⠙⢙⠹⢹ ⡁⣁⡡⣡⡑⣑⡱⣱⡉⣉⡩⣩⡙⣙⡹⣹ ⠅⢅⠥⢥⠕⢕⠵⢵⠍⢍⠭⢭⠝⢝⠽⢽ ⡅⣅⡥⣥⡕⣕⡵⣵⡍⣍⡭⣭⡝⣝⡽⣽ ⠃⢃⠣⢣⠓⢓⠳⢳⠋⢋⠫⢫⠛⢛⠻⢻ ⡃⣃⡣⣣⡓⣓⡳⣳⡋⣋⡫⣫⡛⣛⡻⣻ ⠇⢇⠧⢧⠗⢗⠷⢷⠏⢏⠯⢯⠟⢟⠿⢿ ⡇⣇⡧⣧⡗⣗⡷⣷⡏⣏⡯⣯⡟⣟⡿⣿ Notes: The first char is a blank Braille char, not space. The 2nd 1/2 all have dot 1 present (lines 9-16). The 2nd 1/4 all have dot 2 present (lines 5-8). The 2nd 1/8 all have dot 3 present (lines 3-4). The 2nd 1/16 all have dot 7 present (line 2). The 2nd 1/32 all have dot 4 present (2nd 1/2 of line 1, chars 9-16). The 2nd 1/64 all have dot 5 present (2nd 1/4 of line 1, chars 5-8). The 2nd 1/128 all have dot 6 present (2nd 1/8 of line 1, chars 3-4). The 2nd 1/256 all have dot 8 present (2nd 1/16 of line 1, char 2). Below is code to generate the 256 chars in that order.

//JavaScript: print 256 Braille chars in binary representation order:

function NumToBraille(vNum)
{
	let vOffset = 0;
	if (vNum & 128) vOffset |= 1;   //dot 1
	if (vNum & 64)  vOffset |= 2;   //dot 2
	if (vNum & 32)  vOffset |= 4;   //dot 3
	if (vNum & 16)  vOffset |= 64;  //dot 7
	if (vNum & 8)   vOffset |= 8;   //dot 4
	if (vNum & 4)   vOffset |= 16;  //dot 5
	if (vNum & 2)   vOffset |= 32;  //dot 6
	if (vNum & 1)   vOffset |= 128; //dot 8
	return String.fromCharCode(0x2800 + vOffset);
}

function BrailleToNum(vChar)
{
	const vOffset = vChar.charCodeAt(0) - 0x2800;
	let vNum = 0;
	if (vOffset & 1)   vNum |= 128; //dot 1
	if (vOffset & 2)   vNum |= 64;  //dot 2
	if (vOffset & 4)   vNum |= 32;  //dot 3
	if (vOffset & 64)  vNum |= 16;  //dot 7
	if (vOffset & 8)   vNum |= 8;   //dot 4
	if (vOffset & 16)  vNum |= 4;   //dot 5
	if (vOffset & 32)  vNum |= 2;   //dot 1
	if (vOffset & 128) vNum |= 1;   //dot 8
	return vNum;
}

let vOutput = "";
for (let i = 0; i < 256; i++)
	vOutput += NumToBraille(i);
console.log(vOutput);
console.log(1 == BrailleToNum(NumToBraille(1)));

#Python: print 256 Braille chars in binary representation order:

def NumToBraille(vNum):
	vOffset = 0
	if vNum & 128: vOffset |= 1   #dot 1
	if vNum & 64:  vOffset |= 2   #dot 2
	if vNum & 32:  vOffset |= 4   #dot 3
	if vNum & 16:  vOffset |= 64  #dot 7
	if vNum & 8:   vOffset |= 8   #dot 4
	if vNum & 4:   vOffset |= 16  #dot 5
	if vNum & 2:   vOffset |= 32  #dot 6
	if vNum & 1:   vOffset |= 128 #dot 8
	return chr(0x2800 + vOffset)

def BrailleToNum(vChar):
    vOffset = ord(vChar) - 0x2800
    vNum = 0
    if vOffset & 1:   vNum |= 128 #dot 1
    if vOffset & 2:   vNum |= 64  #dot 2
    if vOffset & 4:   vNum |= 32  #dot 3
    if vOffset & 64:  vNum |= 16  #dot 7
    if vOffset & 8:   vNum |= 8   #dot 4
    if vOffset & 16:  vNum |= 4   #dot 5
    if vOffset & 32:  vNum |= 2   #dot 6
    if vOffset & 128: vNum |= 1   #dot 8
    return vNum

oChars = []
for i in range(256):
	oChars.append(NumToBraille(i))
vOutput = "".join(oChars)
print(vOutput)
print(1 == BrailleToNum(NumToBraille(1)))

Links

Braille - Wikipedia English Braille - Wikipedia Braille Patterns - Wikipedia NamesList.txt [Unicode characters and names e.g. 'BRAILLE PATTERN BLANK' to 'BRAILLE PATTERN DOTS-12345678'] The Braille Alphabet – PharmaBraille How To Read & Write Braille + The History of Braille! - YouTube [Perkins-style Braille keyboard: 13:55-15:47]

Author's View

Accessibility 'In 1824, at the age of fifteen, [Louis Braille] developed the braille code based on the French alphabet as an improvement on night writing.' Source: Braille - Wikipedia Braille is useful for accessibility, including within literacy and software. An accessibility note: QWERTY keyboards have tactile bumps on the F, J and Numpad5 keys. QWERTY keys (A)SDF and JKL(;) are sometimes used for simulating Perkins-style Braille keyboards. Notation systems As someone familiar with literacy, mathematics and programming, Braille is interesting as a notation system. Some notation systems: The alphabet. Roman numerals. Punctuation. The IPA (International Phonetic Alphabet). (And my JEEPA and other easier-to-use alternatives.) The NATO phonetic alphabet. Morse code. Braille. Mathematical symbols and notation. For which Euler gets much credit for setting a standard. Programming operators, including the ternary operator. Programming syntax such as curly braces for grouping lines, function calls via 'MyFunc(MyArg1, MyArg2)', return statements. ISO country and language codes. ISO dates, week numbers, and weekday numbers. As is common, an existing system with some significant qualities (night writing), is itself significantly improved (Braille). Critically, 6 dots is far more practical than 12. Braille has the benefit that all of the numerals, and 25 of 26 letters, can be derived from 10 symbols (for A-J). This handy anticlockwise 'corners' mnemonic helps learn 4 of those 10 symbols. f/6⠋⠙d/4 h/8⠓⠚j/0 That leaves: ⠃b/2. And: ⠁a/1 ⠉c/3 ⠑e/5 ⠛g/7 ⠊i/9. A case study in teaching I often take my own notes on things, and collect resources by others, and share the best ones. Collecting/combining/critiquing and sometimes improving/inventing/expanding the best explanations is the best way to improve education. Braille is a subject people often have no prior knowledge of, so it's interesting as a test case, to see how quickly it can be learnt and how best to teach it. I found mastering the 10 symbols was the key, and eventually invented mnemonics that made them instantly memorable for me, that I listed above. (I invented all the mnemonics listed above for individual/multiple letters except for top half of 'g' and...) I didn't invent this anticlockwise 'corners' mnemonic, however, but found it extremely useful once I'd come across it: f/6⠋⠙d/4 h/8⠓⠚j/0 Once I felt that I knew the 26 symbols fairly well, I tested my knowledge on some Braille-embossed cartons bought from the chemist. If the carton was upside-down, you'd notice surprisingly more dot 6's than usual. A slight problem was that once a sticker covered one or two Braille characters. I was able to do it, but my main difficulty was distinguishing between characters, where they end/begin, they feel so packed together horizontally, with no space in-between them. I could imagine if I had a machine, that gave you larger gaps, or a gap 'mark' between letters, it would be much easier. Programming A potential use for Braille is to provide 1 symbol for each of 256 chars. This could be useful for inspecting binary files, giving 1 symbol per character. Or... you can use printable Unicode characters, but use Braille characters for any unprintable ones. All files are measured by their size in bytes, where each byte is a number from 0 to 255. Typing I have investigated ways to type at speed. Initially I was an extremely fast touch-typist. Then I discovered Excel autocorrect and AutoHotkey hotstrings, as ways to do text expansion from abbreviations to longer strings. This has greatly reduced the number of characters I type day-to-day, and also allows me to very often avoid pressing the shift key, to capitalise characters. E.g. 'en-' to 'education', 'kg-' to 'knowledge', 'ed-' to 'England'. I settled on auto-generating 'first n letters + last letter (excluding silent e)' and 'first n letters of each word' patterns, to pre-populate my hotstring dictionaries versus creating hotstrings every time I needed one. E.g. dift=different,difficult,differentiate medn=medicine,Mediterranean,medallion,medication,methodisation isanew=Isaac Newton isne=Isaac Newton There are further notes here: hotstring demo - Bazzle. A programmer told me about chording. E.g. you have 5 buttons, one for each finger/thumb, and depending on which ones are touching a sensor, you type a character. It's the same principle as playing a chord on a piano such as C-E-G. This can be one of the fastest ways to type, one advantage is that your hand can stay in one place, it doesn't have to move. This idea is the same principle used by Perkins-style Braille keyboards and stenography keyboards. Since I'd learnt Braille, this was potentially a pattern of chords for each letter that I could use as chords for writing text. I.e. I could try Braille instead of learning some other system. I experimented with using 6 keys of a QWERTY keyboard as a Braille keyboard, via AutoHotkey, briefly in July 2026, something I might come back to in future. There is a link above to a YouTube video about Perkins-style Braille keyboards. They typically have 9 keys (listed left-to-right): Line Spacer (Enter) Dot 3 Dot 2 Dot 1 Space Bar Dot 4 Dot 5 Dot 6 Backspace An alternative layout works like this: Dot 7 (Backspace when pressed by itself) Dot 3 Dot 2 Dot 1 Space Bar Dot 4 Dot 5 Dot 6 Dot 8 (Enter when pressed by itself) Note: backspace and enter are confusingly swapped. Stenography keyboards have 7 left-hand side consonant keys, 4 vowel keys, 10 right-hand side consonant keys. You can use chords to type syllables phonetically and/or custom abbreviations. A syllable contains one or more vowel sounds, and may start and/or end with consonant sounds, hence the left/right splitting of consonant keys on the keyboard.