Morse Code Assistive Input

What Morse code means in accessibility

Morse code is often remembered as a radio or telegraph system, but in accessibility it can be a compact input language. A person can produce text and commands with one reliable action, two reliable actions, or a timing-based switch. This provides a robust alternative to complex multi-finger movements, satisfying WCAG 2.5.1 (Pointer Gestures) by ensuring operation does not require path-dependent or multipoint gestures.

In product design, Morse code should be treated as an access method, not a novelty. The interface must make timing adjustable, feedback immediate, correction easy, and focus movement predictable. The goal is not to make everyone memorize Morse. The goal is to support the users who already rely on it or can learn it because it matches their motor ability.

The timing model

Morse input depends on relative duration. The dot is the base unit. A dash is longer. Pauses separate parts, letters, and words. Assistive software should let the user define what short and long mean for their body, hardware, fatigue level, and environment.

Letter examples

These examples use international Morse code. In a real assistive product, the same input layer may also expose predictions, shortcuts, custom phrases, or command macros to reduce effort.

How a person actually uses it

A practical Morse flow starts with calibration. The user presses the switch a few times so the software can estimate dot length, dash threshold, pause tolerance, and accidental bounce. After that, each press updates a visible and audible buffer. When the letter timeout passes, the buffer commits to a character. The user can continue typing, accept a word prediction, delete the last character, or switch into command mode.

Realistic interaction examples

// React hook useMorseInput for custom switch events
import { useState, useEffect, useRef } from "react";

export function useMorseInput(dotThreshold = 200, letterTimeout = 1000) {
  const [buffer, setBuffer] = useState("");
  const [committedText, setCommittedText] = useState("");
  const pressStart = useRef(null);
  const commitTimer = useRef(null);

  const handleSwitchDown = () => {
    if (pressStart.current) return;
    pressStart.current = Date.now();
    if (commitTimer.current) clearTimeout(commitTimer.current);
  };

  const handleSwitchUp = () => {
    if (!pressStart.current) return;
    const duration = Date.now() - pressStart.current;
    pressStart.current = null;

    const signal = duration <= dotThreshold ? "." : "-";
    setBuffer((prev) => prev + signal);

    commitTimer.current = setTimeout(() => {
      setBuffer((currentBuffer) => {
        if (currentBuffer) {
          // Trigger decoding translation here
          setCommittedText((msg) => msg + decodeMorse(currentBuffer));
        }
        return "";
      });
    }, letterTimeout);
  };

  return { buffer, committedText, handleSwitchDown, handleSwitchUp };
}

Design requirements for Morse input

Recommended input settings

Defaults should be gentle and adjustable. A fast expert user may want short timeouts; a new or fatigued user may need slower timing and stronger feedback. Store these settings and make them easy to export or reset.

Common mistakes

Testing checklist

What good support feels like

Good Morse support feels calm. The system waits long enough, confirms each signal clearly, offers fast correction, and never punishes the user for a different rhythm. It should be possible to write, navigate, correct, submit, and cancel with the same access method from start to finish.