Morse Code to English Translator

What counts as valid input

Decoding is really a spacing problem. The dots and dashes tell you which letter, but the gaps tell you where one letter ends and the next begins, and where one word ends and the next starts. That is why a decoder lives or dies on how well it reads spacing.

This translator accepts the formats you will actually run into in the wild:

• Dots as periods (.) and dashes as hyphens (-), the near-universal written form
• A single space between letters, the way most people write it out
• A forward slash (/) or a double space between words
• Common substitutes like the interpunct for a dot or an em dash for a dash, which it normalises before decoding

What it cannot guess is a message with no spacing at all. If someone hands you "...---..." with no gaps, that could be SOS or it could be a dozen other letter combinations, because Morse is not self-punctuating. When in doubt, ask the sender to add spaces between letters.

Reading the output and spotting errors

When the decode succeeds you get clean English, capitalised as plain uppercase because Morse carries no case information. If a group of dots and dashes matches no known letter, the translator shows a small marker rather than silently dropping it, so you know exactly where the message went sideways instead of getting a plausible-looking but wrong sentence.

Those markers are your debugging friend. A stray extra dot, a dash that should have been a dot, or a missing letter-space are the three most common ways a hand-sent message gets garbled, and they almost always produce a single unknown group surrounded by perfectly good text. Fix the spacing around that one group and the whole message usually snaps into focus.

Where the messy signals come from

Half the fun of a decoder is the detective work, because real Morse arrives messy. If you copied a signal by ear from a shortwave radio, your spacing reflects a human fist, and humans are inconsistent. If you pulled it from an old telegram, a puzzle, or a geocache, someone may have used a different convention for word gaps. If a friend sent it as a joke, they may have spaced it however felt natural.

The decoder is built to absorb that variety. It treats runs of extra whitespace as word breaks, tolerates a trailing slash, and ignores stray characters that clearly are not part of the code, like a leftover quotation mark. The goal is that you paste whatever you have and get a sensible answer, then clean up only the parts it flags.

Decoding by ear vs decoding by paste

There are two ways people end up with Morse to decode, and they need slightly different habits. If you already have the written dots and dashes, this text decoder is all you need. If you are hearing a live tone and trying to catch it, you are copying by ear, which is a genuine skill the American Radio Relay League (ARRL) has been teaching hams for over a century.

A good bridge trick: as you hear each letter, write the dots and dashes on paper rather than trying to name the letter in real time. Beginners who translate in their head fall behind and panic. Beginners who just scribble dots and dashes, then paste the lot into a decoder afterward, stay calm and get the whole message. Once your ear is faster, you graduate to hearing whole letters, but there is no shame in the paper-and-paste method while you learn.

A worked example, gap by gap

Nothing makes decoding click like watching it happen, so here is a short one done slowly. Suppose you paste this: .... . .-.. .-.. --- / .-- --- .-. .-.. -.. The decoder first splits on the word slash, giving it two words to work on. Inside the first word it splits on single spaces into five groups: .... then . then .-.. then .-.. then ---. It looks each up: .... is H, . is E, .-.. is L, .-.. is L again, --- is O. First word, HELLO.

The second word splits into .-- --- .-. .-.. -.., which resolve to W, O, R, L, D. Put the two words back together across that slash and you have HELLO WORLD. Notice what did the real work: not the dots and dashes on their own, but the spaces that told the decoder where each of those ten letters started and stopped, and the single slash that kept the two words apart. Remove the letter spaces and you would have one giant unrecognisable group. Remove the slash and you would get HELLOWORLD run together. The dots and dashes were never in doubt; the structure is what the spacing supplied.

Work through your own name the same way once, splitting on gaps before you look anything up, and decoding stops feeling like magic and starts feeling like the simple two-level split it actually is.

The reason this two-level split matters so much is that it is the whole reason Morse can be unambiguous at all. There is no marker that says 'letter ends here' inside the dots and dashes themselves, the way a comma or a space works in written English; the only boundary is the length of the silence. A three-unit gap says 'new letter', a seven-unit gap says 'new word', and everything hangs on the receiver being able to tell those two silences apart. When you paste a signal, you are handing the decoder a series of dots, dashes, and silences and asking it to rebuild that hierarchy. Get the silences right and the letters take care of themselves; get them wrong and even flawless dots and dashes collapse into nonsense. Understanding that is what separates people who can rescue a garbled message from people who give up on it.

Decoding under real-world noise

Textbook Morse is tidy. The Morse you actually decode, off a forum post, a friend's handwriting, a faint recording someone transcribed, arrives with rough edges, and a good decoder habit is to expect that rather than be surprised by it. The most common real-world messes are an extra trailing slash at the end of a message, doubled spaces sprinkled unevenly, a stray dot from a slip of the pen, and mixed dash characters where someone used a hyphen in one spot and an em dash in another.

This translator smooths most of that automatically: it normalises the different dot and dash characters, treats runs of extra space as word breaks, and ignores obvious junk like a leftover bracket. What it cannot do is read your sender's mind about intent, so when a decode comes out ninety percent right with one weird patch, the fastest fix is almost always yours to make: look at the gaps around the patch, decide whether a letter or a word break went missing, and add it. I have rescued dozens of 'broken' messages this way, and in nearly every case the sender's dots and dashes were fine and only their spacing had wandered. Treat the decoder as a fast first pass and yourself as the editor, and very little stays undecodable for long.

The standard behind the decode

This translator decodes against International Morse Code as defined in ITU-R Recommendation M.1677, the same table amateur operators and maritime services use worldwide, and the one thoroughly documented on Wikipedia's Morse code page. That matters for a decoder specifically, because there is more than one Morse. The older American (or "railroad") Morse used different patterns for several letters and even internal spaces inside characters, so a decoder built for international Morse will happily mistranslate a genuine 1860s landline telegram.

For virtually everything you will encounter today, international Morse is the right assumption. If you know you are dealing with historical American Morse, say from a museum artifact, you will want a specialist reference instead, because the letters C, F, L, O, P, Q, R, X, Y, Z and several numbers simply do not match.