Braille Translator

The Braille Translator is a free browser tool that converts plain English text into Grade-1 Braille Unicode and decodes the same cells back into plain letters. It is built for anyone who needs a quick, reliable way to produce or read a Braille string, accessibility advocates preparing materials, teachers producing worksheets, students learning the alphabet, developers checking that a translation pipeline produces the expected output, and curious readers who simply want to see what their name looks like in Braille. Because the output is ordinary Unicode text rather than a picture or a font, the result is portable: you can copy it into emails, social media posts, web pages, documents on your computer, or any system that supports Unicode, and it will appear as a Braille string on the receiving end.

The translator handles the full English alphabet (uppercase and lowercase), the digits 0 through 9, and a set of common punctuation marks (period, comma, semicolon, colon, question mark, exclamation mark, apostrophe, quotation mark, and hyphen). It is intentionally simple, it performs a one-to-one transcription with no shorthand contractions, and that simplicity is its strength. Anything you can read in the input box will appear in the output box in a predictable, fully reversible way. If you want to round-trip a string (encode, then decode, and recover the original) the tool will do that exactly, character for character.

What is Braille?

Braille is a tactile writing system developed in the early 19th century by Louis Braille, a blind French student who wanted a way to read and write as fluently as sighted peers read print. The system encodes letters, numbers, punctuation, and even music and mathematical notation as patterns of raised dots arranged in a rectangular cell. Standard Braille uses a six-dot cell, two dots wide and three dots tall, with each dot either raised or not. Because each cell has six binary dots, there are exactly 64 possible configurations, and Western Braille uses almost all of them for letters, digits, punctuation, and a long list of contractions and abbreviations.

A reader runs their fingertips across the dots and feels the configuration. For someone who reads Braille fluently, the experience is similar to the way a sighted reader runs their eyes across shapes on a page, the tactile pattern is recognised as a whole, not decoded dot-by-dot. The minimum reading age for fluent Braille is roughly the same as the minimum reading age for print, and Braille-literate readers are typically just as fast as print readers within their own language. In countries with strong Braille education programmes, blind students read school textbooks, do maths and science, take notes, and write essays using Braille from primary school through university.

Why Grade-1?

Braille comes in two main grades. Grade-1 (also called uncontracted or alphabetic Braille) is a one-to-one transcription: every letter of the written language becomes its own cell, and every digit and punctuation mark becomes its own cell too. There are no abbreviations. Grade-1 is the form most beginners learn, the form used in signage, elevator buttons, and short labels, and the form most people encounter outside dedicated reading materials. It is also the form that maps cleanly onto Unicode, which is why this tool uses it.

Grade-2 (or contracted) Braille adds around 200 common letter combinations and whole-word contractions to reduce the physical size of texts and speed up reading. For example, the English contraction for "the" is a single cell, and the contraction for "and" is a single cell. Grade-2 looks substantially shorter on the page than Grade-1, and fluent readers find it faster, but it requires the reader to learn the contraction rules. It is meaningfully harder to implement in software because the contractions interact with each other and depend on the surrounding text, and it is not what most casual users want when they paste a string into a translator. This translator therefore implements Grade-1 exclusively, which keeps the encoding unambiguous and reversible.

How the Unicode Encoding Works

The Unicode block for Braille Patterns runs from U+2800 to U+28FF and covers all 64 possible on/off states of a six-dot cell. The base codepoint, U+2800, is a blank cell with no dots raised; adding the offset of a particular dot pattern to that base produces the codepoint for that cell. For example, the letter "a" in Braille is a single dot in the top-left of the cell (dot 1), so its offset is 1 and its codepoint is U+2801, which renders as ⠁. The letter "b" is dots 1 and 2, so its offset is 3 and its codepoint is U+2803, which renders as ⠃. The letter "z" is dots 1, 3, 5, and 6, so its offset is 0x35 and its codepoint is U+2835, which renders as ⠵.

The exact mapping between dot patterns and codepoints is determined by numbering the dots 1 through 6 (1 at top-left, 2 at middle-left, 3 at bottom-left, 4 at top-right, 5 at middle-right, 6 at bottom-right) and then summing the bit values dot 1 = 1, dot 2 = 2, dot 3 = 4, dot 4 = 8, dot 5 = 16, dot 6 = 32. Because the 64 combinations fit neatly into a 256-codepoint block, the Unicode Consortium could fit all of Braille into a single reserved range without needing combining characters, ligatures, or any of the usual Unicode machinery for complex scripts. Every Braille cell is exactly one codepoint, every Braille string is a normal UTF-8 string, and Braille text survives any text-processing pipeline that respects UTF-8.

Why Numbers and Capitals Need Indicators

The 26 letters of the English alphabet and the 10 digits together use 36 of the 64 available cells, but there is an overlap problem: digits 1 through 9 and 0 are encoded using the same cells as the letters a through j. The cell for "a" is also the cell for "1", the cell for "b" is also the cell for "2", and so on. Without some disambiguating marker, the reader could not tell whether a sequence of cells was meant to be a word or a number. Braille solves this with a number indicator (⠼, dots 3-4-5-6, codepoint U+283C) that tells the reader: the next cells are digits, not letters, until the next space or other non-letter cell. The translator's encode mode inserts the number indicator before the first digit of any run and turns it off again at the next non-digit character.

Capital letters have a similar problem. There are only 64 cells, and they already have to encode 26 lowercase letters, 10 digits, and a long list of punctuation marks. There is no room for a separate uppercase letter set. Instead, Braille uses a capital indicator (⠠, dot 6 alone, codepoint U+2800+0x20 = U+2820) that marks the next letter as uppercase. After a capital indicator, the transcriber reads the next cell as an uppercase letter, and then reverts to lowercase mode. This translator inserts the capital indicator before every uppercase letter, and the decode mode reads the capital indicator and converts the following lowercase letter to uppercase.

How to Use This Translator

1. Pick Text → Braille to encode, or Braille → Text to decode.
2. Type or paste your text into the input box. Conversion happens live as you type, so you do not need to press a button.
3. Click the Copy button next to the result to grab the Braille string (or the decoded text) for use elsewhere.
4. Glance at the info panel under the result to see the dot pattern that produced the last character, useful when you are learning the alphabet and want to know which dots correspond to which letters.

The translator preserves spaces, line breaks, and tabs exactly. Unsupported characters pass through unchanged so that you can see, in the output, exactly which characters did not translate. If you feed it a string that mixes English letters with another script (say, Cyrillic or Greek), the non-English letters will appear in the output unchanged and the English letters will be transcribed. This is intentional: better to preserve what you typed than to silently drop it.

Worked Examples

Example 1, A simple word

The word "hello" is encoded as five cells, one for each letter. h = ⠓, e = ⠑, l = ⠇, l = ⠇, o = ⠕. The result is the string ⠓⠑⠇⠇⠕. The encoding is purely mechanical: look up the letter in the standard table, prepend any indicator signs (none here, because every letter is lowercase), and concatenate.

Example 2, A sentence with a capital letter

The string "Hi" has two letters, the first one uppercase. The encoder emits the capital indicator (⠠) followed by the lowercase cell for h (⠓) and the lowercase cell for i (⠊). The result is ⠠⠓⠊. The decoder reads the same string and produces "Hi" by recognising the capital indicator and converting the next letter to uppercase.

Example 3, A number

The string "123" is three digits. The encoder emits the number indicator (⠼) once, then the cells for 1 (⠁), 2 (⠃), and 3 (⠉). The result is ⠼⠁⠃⠉. The decoder reads the number indicator, enters number mode, and emits the digits 1, 2, 3 in order.

Example 4, A mixed string

The string "Hi 5" contains a capital letter, a space, and a digit. The encoder emits the capital indicator, the h cell, the i cell, a literal space, the number indicator, and the cell for 5. The result is ⠠⠓⠊ ⠼⠑. The decoder reads the same string and recovers "Hi 5" exactly, including the space.

Example 5, Punctuation

The string "Yes!" is four characters: Y, e, s, and the exclamation mark. The encoder emits the capital indicator, the cell for y, the cell for e, the cell for s, and the punctuation cell for ! (dots 2, 3, 5 = ⠖). The result is ⠠⠽⠑⠎⠖. The decoder reads the capital indicator and the exclamation punctuation cell and recovers "Yes!" exactly.

Where This Translator Is Useful

• Learning the Braille alphabet. The info panel shows the dot pattern for the last character, so you can type a letter and immediately see which dots it uses. This is a great way to build up muscle memory for the cell shapes.
• Classroom materials. Teachers producing worksheets, posters, or flashcards can paste in a phrase and get a Braille transcription in seconds, with no setup and no signup.
• Accessibility content. Web authors, social media managers, and document writers can sprinkle Braille strings into their content as a visual flourish or as a literal accessibility aid.
• Testing Braille-translation pipelines. Developers building larger systems that talk to Braille embossers, refreshable displays, or assistive technology can use this tool to generate expected outputs and compare against them.
• Sanity-checking. Anyone who already has a Braille string, from a friend, a printed document, or another piece of software, can paste it in and read what it says, without installing any Braille font or learning any commands.

Common Mistakes

Mistake 1, Expecting Grade-2 contractions. This translator does not implement the 200-or-so contractions that Grade-2 Braille uses. If you feed it a long English phrase and expect a compact Grade-2 output, you will be disappointed. The output will be a faithful Grade-1 transcription, which is verbose by comparison. If you need Grade-2, you need a dedicated Grade-2 translation tool or a library that implements the per-language rule set.

Mistake 2, Treating the Unicode output as a picture. The result is a Unicode string, not an image. Whether you can see the dot patterns depends on the fonts installed on the device you paste into. Most modern operating systems ship with a font that covers the Braille Patterns block, and modern browsers will render it correctly. If you see blank squares or question marks, the receiving system does not have an appropriate font. Install a Unicode-complete font (almost any modern system font qualifies) and the dots will appear.

Mistake 3, Confusing the number-indicator switch. When encoding a number, the translator inserts the number indicator (⠼) once at the start of the run and then expects to switch back to letter mode at the next non-digit. If you type "abc123def", the result is the Braille for "abc" followed by the number indicator and the Braille for "123" followed by the Braille for "def", the number indicator is not silently dropped between "123" and "d". This is correct Braille behaviour, but it can be surprising if you did not expect it.

Mistake 4, Forgetting uppercase. The capital indicator is per-letter, not per-word. If you type "HELLO", the encoded string contains five capital indicators (one before each letter), not one at the start of the word. Again, this is correct Braille behaviour, but it does make the output longer than English readers sometimes expect.

Mistake 5, Mixing scripts. If you type a Unicode string that mixes English letters with another script (Greek, Cyrillic, Arabic, Chinese characters), the translator will transcribe the English letters and pass the other characters through unchanged. It will not try to transcribe the non-English characters into Braille. That is a deliberate scope choice: a translator that tries to handle every script would need a much larger table and a per-script set of conventions, and most users want a tool that does one job well.

Frequently Asked Questions

What is Braille?

Braille is a tactile writing system that uses patterns of raised dots in a six-dot cell to encode letters, numbers, punctuation, and specialised notations like music and mathematics. It was invented by Louis Braille in the early 19th century and is the primary reading and writing medium for many blind and visually impaired people around the world. A Braille reader feels the dots with their fingertips and learns to recognise the patterns as fluently as a sighted reader recognises printed shapes.

What is the difference between Grade-1 and Grade-2 Braille?

Grade-1 Braille (also called uncontracted or alphabetic Braille) is a one-to-one transcription: every letter becomes its own cell, with no abbreviations. Grade-2 Braille (also called contracted Braille) adds roughly 200 common letter combinations and whole-word contractions to reduce the size of the text and speed up reading. Grade-1 is what beginners learn, what is used in signage and short labels, and what maps cleanly onto Unicode. This translator implements Grade-1.

Why is the output a Unicode string and not a picture?

The Unicode block for Braille Patterns (U+2800-U+28FF) reserves one codepoint for every possible combination of the six dots in a Braille cell. That means any Braille string can be represented as a normal Unicode text string, with one codepoint per cell. The output is therefore small, portable, and copy-pasteable: it can be sent through email, stored in a database, or pasted into a website, and it will render as Braille on any system with a Unicode-complete font. The same Unicode string is what embossers and Braille translation software ultimately produce on the page.

Why does the translator insert a number indicator before digits?

In literary Braille, the digits 1 through 9 and 0 are encoded using the same cells as the letters a through j. Without a disambiguating marker, a reader could not tell whether a sequence of cells was meant to be a word or a number. The number indicator (⠼) tells the reader: the next cells are digits, not letters, until the next space or non-letter cell. This translator inserts the number indicator once before the first digit in any run and removes it at the next non-digit character.

Why does the translator insert a capital indicator before uppercase letters?

There are only 64 possible cells in a six-dot Braille cell, and they already have to encode 26 lowercase letters, 10 digits, and a long list of punctuation marks. There is no room for a separate uppercase letter set. Instead, Braille uses a capital indicator (⠠) that marks the next letter as uppercase. This translator inserts the capital indicator before every uppercase letter, and the decoder reads the indicator and converts the following lowercase letter to uppercase.

Can I use the output with a Braille embosser?

In principle, yes. The Unicode Braille string this translator produces is the same Unicode string that an embosser driver expects to receive in most translation pipelines. The embosser converts the Unicode cells into physical dot patterns on paper. In practice, real embossing workflows often add extra features (interpoint spacing, headers, footers, page numbers, table support) that require dedicated translation software, but for short strings and simple documents, the translator output is a valid starting point.

Does this translator work for languages other than English?

This translator implements the Grade-1 Braille conventions for English: letters a-z, digits 0 to 9, and a small set of common punctuation marks. Other languages use their own Braille codes (Spanish Braille, French Braille, Arabic Braille, Mandarin Braille, and so on), each with its own conventions for letters with diacritics, accented characters, and punctuation. The translation tables in this tool are English-specific. If you need a different language, look for a Braille translator that targets that language's code.

Is the translation reversible?

Yes. The encode and decode modes are exact inverses for the supported character set. You can encode a string, paste the result into the decode mode, and get the original string back, character for character. If you include unsupported characters in the input, they will be passed through unchanged in both directions, so they will round-trip correctly too.

Also try these free tools:

• ASCII to Hex Converter, convert ASCII text to hex bytes.
• Morse Code Translator, encode and decode Morse code in your browser.
• Pig Latin Translator, convert English to Pig Latin and back.