Morse Code Translator & Audio Player

Translate text bidirectionally between English and International Morse Code with interactive audio tone playback.

4.9 / 5· 148 verified ratings
•
100% Client-Side Privacy
•
Verified 2026 Engine
Instant Computation • 100% Client-Side Privacy • Zero Server Upload
Loading tool engine...
Frequently Used With:Age & Date Calculator →Gas & Trip Fuel Cost Calculator →GPA & Grade Point Average Calculator →Date Difference & Business Days Calculator →
Institutional-Grade Accuracy & Client-Side Privacy Guarantee

Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.

What is Morse Code?

Morse Code is a character telecommunication encoding system designed to transmit textual information across electrical telegraph wires, high-frequency continuous wave (CW) radio frequencies, optical signal lamps, and auditory clicks. Co-invented in the late 1830s by American polymath Samuel F. B. Morse and machinist Alfred Vail, Morse Code laid the foundations for the global digital telecommunications revolution.

Standardized internationally by the International Telecommunication Union (ITU) under Recommendation ITU-R M.1677-1 (International Morse Code), the system encodes each Latin alphanumeric character, punctuation symbol, and procedural sign (prosign) into unique sequences of short and long signals, known formally as:

  • Dits (represented graphically as dots .)
  • Dahs (represented graphically as dashes -)

Despite the advent of high-speed satellite internet, voice over IP (VoIP), and fiber-optic communication, Morse Code remains actively utilized across amateur radio (ham radio), maritime distress beacons, aeronautical navigation aids (VOR and NDB identifier beacons), military covert signaling, and assistive accessibility technology. Because Morse Code (CW) requires an exceptionally narrow radio frequency bandwidth (under 100 Hz), it can penetrate atmospheric interference and propagate across intercontinental distances where voice radiotelephony completely fails.


The Mathematical Timing Architecture of Morse Code (ITU-R M.1677)

Morse Code is not merely a collection of dots and dashes; it is a precision rhythmic time-division protocol. The duration of every element is strictly derived from a single fundamental unit of time, the Dit Duration ($T$):

flowchart TD
    BaseUnit["Fundamental Time Unit: Dit Duration (T)"] --> Dit["1. Dit / Dot (.): Exactly 1 Time Unit (T)"]
    BaseUnit --> Dah["2. Dah / Dash (-): Exactly 3 Time Units (3T)"]
    BaseUnit --> IntraChar["3. Intra-Character Gap: 1 Time Unit of Silence (1T)"]
    BaseUnit --> InterChar["4. Inter-Letter Gap: 3 Time Units of Silence (3T)"]
    BaseUnit --> InterWord["5. Inter-Word Gap: 7 Time Units of Silence (7T)"]

1. The Five Strict ITU Temporal Ratios

  1. The length of a Dit (.) is exactly one unit ($1T$).
  2. The length of a Dah (-) is exactly three units ($3T$).
  3. The silent interval between individual dits and dahs within the same character is one unit ($1T$).
  4. The silent interval between two successive letters in a word is three units ($3T$).
  5. The silent interval between two words is seven units ($7T$).

2. Calculating Words Per Minute (WPM) via the "PARIS" Standard

To standardize transmission speed in Words Per Minute (WPM), the international community uses the benchmark word "PARIS". The word "PARIS" was selected because its transmission length—including intra-character, inter-character, and trailing inter-word spacing—equals exactly 50 fundamental time units ($50T$):

$$\text{P } (\cdot - - \cdot) + \text{A } (\cdot -) + \text{R } (\cdot - \cdot) + \text{I } (\cdot \cdot) + \text{S } (\cdot \cdot \cdot) + \text{Word Space} = 50 \text{ Units}$$

$$\text{Total Dit Units per Minute} = 50 \times \text{WPM}$$

Solving for the fundamental Dit duration ($T$ in seconds):

$$T = \frac{60 \text{ seconds}}{50 \times \text{WPM}} = \frac{1.2}{\text{WPM}} \text{ seconds}$$

Transmission SpeedDit / Dot Duration ($T$)Dah / Dash Duration ($3T$)Inter-Letter Pause ($3T$)Inter-Word Pause ($7T$)Operational Domain
5 WPM (Novice)$240.0\text{ ms}$$720.0\text{ ms}$$720.0\text{ ms}$$1,680.0\text{ ms}$Beginner training, survival emergency signaling
12 WPM (Standard)$100.0\text{ ms}$$300.0\text{ ms}$$300.0\text{ ms}$$700.0\text{ ms}$Former maritime license requirement
20 WPM (Proficient)$60.0\text{ ms}$$180.0\text{ ms}$$180.0\text{ ms}$$420.0\text{ ms}$Standard amateur radio (CW) conversational speed
35 WPM (Expert)$34.3\text{ ms}$$102.9\text{ ms}$$102.9\text{ ms}$$240.0\text{ ms}$High-speed telegraphy competitions, contest pileups

Comprehensive International Morse Code Reference Matrix

The following table details the official ITU-R M.1677-1 mappings for the Latin alphabet, numbers, and core punctuation:

CharacterMorse RepresentationCharacterMorse RepresentationCharacterMorse Representation
A.-N-.0-----
B-...O---1.----
C-.-.P.--.2..---
D-..Q--.-3...--
E.R.-.4....-
F..-.S...5.....
G--.T-6-....
H....U..-7--...
I..V...-8---..
J.___W.--9----.
K-.-X-..-Period (.).-.-.-
L.-..Y-.--Comma (,)--..--
M--Z--..Question (?)..--..
Slash (/)-..-.Equals (=)-...-At Symbol (@).--.-.

Procedural Signals (Prosigns)

Prosigns are special operational codes sent as a single, continuous run without inter-letter pauses:

  • SOS (Distress): ...---... (Sent continuously as 9 elements; NOT separate letters S, O, S).
  • AR (End of Transmission): .-.-. (Over and out on message).
  • SK (End of Contact): ...-.- (Signing off completely).

Practical Implementation Examples

Python: Robust Bidirectional Morse Code Encoder & Decoder

from typing import Dict

# Official ITU-R M.1677-1 Dictionary
MORSE_CODE_MAP = {
    'A': '.-',     'B': '-...',   'C': '-.-.',   'D': '-..',
    'E': '.',      'F': '..-.',   'G': '--.',    'H': '....',
    'I': '..',     'J': '.---',   'K': '-.-',    'L': '.-..',
    'M': '--',     'N': '-.',     'O': '---',    'P': '.--.',
    'Q': '--.-',   'R': '.-.',    'S': '...',    'T': '-',
    'U': '..-',    'V': '...-',   'W': '.--',    'X': '-..-',
    'Y': '-.--',   'Z': '--..',
    '0': '-----',  '1': '.----',  '2': '..---',  '3': '...--',
    '4': '....-',  '5': '.....',  '6': '-....',  '7': '--...',
    '8': '---..',  '9': '----.',
    '.': '.-.-.-', ',': '--..--', '?': '..--..', '/': '-..-.',
    '=': '-...-',  '@': '.--.-.', '-': '-....-'
}

REVERSE_MORSE_MAP = {v: k for k, v in MORSE_CODE_MAP.items()}

def text_to_morse(text: str) -> str:
    """Translates plain text into Morse code using spaces between letters and ' / ' between words."""
    words = text.strip().upper().split()
    encoded_words = []

    for word in words:
        encoded_chars = [MORSE_CODE_MAP.get(c, '') for c in word if c in MORSE_CODE_MAP]
        encoded_words.append(' '.join(encoded_chars))

    return ' / '.join(encoded_words)

def morse_to_text(morse_code: str) -> str:
    """Decodes a Morse code string back into plain English text."""
    words = morse_code.strip().split(' / ')
    decoded_words = []

    for word in words:
        letters = word.strip().split()
        decoded_letters = [REVERSE_MORSE_MAP.get(code, '') for code in letters]
        decoded_words.append(''.join(decoded_letters))

    return ' '.join(decoded_words)

# Verification
plain = "AffiChain Core"
encoded = text_to_morse(plain)
print("Plaintext: ", plain)
print("Morse Code:", encoded)
print("Decoded:   ", morse_to_text(encoded))

TypeScript / JavaScript Implementation

export function translateTextToMorse(input: string): string {
  const table: Record<string, string> = {
    A: '.-', B: '-...', C: '-.-.', D: '-..', E: '.', F: '..-.',
    G: '--.', H: '....', I: '..', J: '.---', K: '-.-', L: '.-..',
    M: '--', N: '-.', O: '---', P: '.--.', Q: '--.-', R: '.-.',
    S: '...', T: '-', U: '..-', V: '...-', W: '.--', X: '-..-',
    Y: '-.--', Z: '--..', '1': '.----', '2': '..---', '3': '...--',
    '4': '....-', '5': '.....', '6': '-....', '7': '--...',
    '8': '---..', '9': '----.', '0': '-----'
  };

  return input
    .toUpperCase()
    .split(/\s+/)
    .map(word => 
      word
        .split('')
        .map(ch => table[ch] || '')
        .filter(Boolean)
        .join(' ')
    )
    .join(' / ');
}

Critical Edge Cases & Common Operational Pitfalls

1. The Unspaced Ambiguity Hazard

In Morse code, whitespace is a critical data delimiter. If a system transmits an unspaced stream of symbols, the message becomes mathematically ambiguous:

  • The stream ..-. can be interpreted as:
    • F (..-.)
    • IN (.. and -.)
    • ER (. and .-.)
    • EA (. and .-)
    • EDT (., -.., -) Without the mandatory 3-unit inter-character silent pause, a 10-symbol stream has hundreds of valid permutations.

2. Farnsworth Timing in Education

Novice telegraphers frequently struggle when training at low speeds (e.g., 5 WPM) because their brains learn to count individual dits and dahs rather than recognizing the rhythmic acoustic "melody" of the letter. Under Farnsworth Timing, characters are sent at a rapid 18 to 20 WPM rate, but the silent intervals between letters are stretched. This trains human neural perception to recognize complete letter soundscapes immediately without mental counting.

Frequently Asked Questions

What is the universal distress signal in Morse code?
The distress signal is SOS, represented in Morse code as three dots, three dashes, and three dots (... --- ...).

Explore Related Utilities