Most developers think about accessibility as a checklist: alt text, colour contrast, keyboard navigation, ARIA labels. All of that matters. But there is a deeper question underneath the checklist, and it is the one Morse code has been answering since the 1840s: how little input does a person actually need to say anything?
The answer is two. A short signal and a long signal. A dot and a dash. With just those two inputs, a person can type any letter, any number, any sentence — and people with severe motor disabilities do exactly that, every day, using Morse code switches to operate computers, phones, and communication devices. If your app cannot be used with two buttons, the problem is not the user. It is the interface.
The switch-access reality
For many people with cerebral palsy, ALS, muscular dystrophy, or spinal cord injuries, a keyboard and mouse are not an option. What they can do reliably is press one switch — or two. A switch might be a large button under a hand, a sip-and-puff tube, a blink detector, or a head switch. One switch means "select"; two switches mean "move" and "select". Everything else is software.
This is where Morse code earns its place in modern accessibility. A single switch can send dots and dashes by timing: a short press is a dot, a long press is a dash. Two switches are even easier: one for dots, one for dashes. The code itself does the rest. Twenty-six letters, ten digits, punctuation — all from timing and two states. No eye-tracking camera, no expensive hardware, no custom device. A £10 switch and free software can give someone a full keyboard.
That is not a historical curiosity. It is a live, working input method, and it exposes a design truth most developers never confront: the number of distinct inputs your interface requires is a measure of how many people it excludes.
Why Morse works as an input method
Three properties make Morse code unusually good for switch access, and each one is a lesson for anyone building interfaces.
First, it is binary. Every character is a sequence of exactly two symbols. That maps perfectly onto the cheapest, most reliable assistive hardware in existence: a single switch. Compare that with scanning keyboards, where the user waits for a highlight to sweep across rows and columns and presses a switch at the right moment. Scanning works, but it is slow and mentally exhausting — every keystroke is a timing test. Morse input is direct: the user composes the character, rather than waiting for the interface to offer it.
Second, it is timing-tolerant by design. A dot is one unit, a dash is three, the gap between letters is three units, and the gap between words is seven. Those ratios are guidelines, not a fixed clock speed. A Morse input app can adapt to the user's pace — slowing down for someone whose presses are uneven, speeding up as they gain fluency. Good switch software does exactly this: it learns the user's rhythm instead of demanding machine precision. The lesson for developers is blunt: if your interface punishes slightly slow or slightly uneven input, it is not the user who is failing. Your timing assumptions are.
Third, it degrades gracefully. Miss a dash and you get the wrong letter — but the error is local, one character, and the user knows immediately. There is no cascade, no lost session, no state to rebuild. Contrast that with a gesture-based interface where a misread swipe can close a window, or a voice interface that mishears a command and takes an irreversible action. Morse code's failure mode is a typo, and typos are cheap to fix. Interfaces that fail cheaply are interfaces people can trust.
What this means for the software you ship
You do not need to build a Morse code keyboard to learn from one. The principles transfer directly to ordinary web and app development.
Reduce the number of distinct inputs your interface demands. Every interaction that requires a precise mouse position, a multi-finger gesture, or a specific key combination is a door you have closed. Ask, for each feature: can this be done with a single switch — one button, pressed at the right time? If the answer is no, is the complexity essential, or is it decoration? Tab order, focus visibility, and full keyboard operability are the baseline. A user who can only press Tab and Enter should be able to reach everything.
Make timing forgiving. Timeouts are an accessibility issue, not just a security feature. A session that expires after five minutes of inactivity, a CAPTCHA that must be solved in thirty seconds, a carousel that advances before it can be read — these are all designs that assume a fast, able-bodied user. Give people control over timing: let them pause, extend, and disable time limits. Morse operators learned this in the 19th century: the receiver sets the pace, not the sender.
Design for the cheapest hardware, not the newest. The most powerful assistive technology in the world is useless if it costs thousands of pounds. Morse switch access works with hardware that costs less than a takeaway dinner, and the software is free. When you build for low-end devices, slow connections, and old browsers, you are not just reaching more users — you are reaching the users who need your product most. Performance budgets and progressive enhancement are accessibility features, not just engineering virtues.
Test with real constraints, not just a checklist. Unplug your mouse for an afternoon. Navigate your own product with only a keyboard. Then try it with a single-switch simulator, if you can. The experience is humbling, and it will find problems no automated audit ever will — a focus trap here, a hover-only menu there, a form that cannot be submitted without a pointer. The developers who build the best accessible products are the ones who have felt the friction themselves.
A short history that explains the present
Morse code's accessibility story is not new. In the 1970s and 1980s, as personal computers spread, rehabilitation engineers noticed that Morse input was one of the few ways people with almost no voluntary movement could type. Research groups built Morse keyboards for people who could move only a single muscle — an eyebrow, a finger, a breath. By the 1990s, software like the Morse code input method in early assistive-technology suites was letting users write emails, control cursors, and even program, all with two switches.
The same principle has since spread far beyond Morse itself. Switch access is now a built-in feature of Android and iOS. Eye-gaze typing, head tracking, and voice control all follow the same idea: take whatever input the user can reliably produce, and build the whole interface on top of it. Morse code was simply the first proof that two signals are enough — and it remains the clearest demonstration of the idea, because there is nothing to hide behind. No sensors, no machine learning, no cloud. Two buttons, a timing rule, and a codebook.
Try it yourself
The fastest way to understand Morse as an input method is to feel it. Take a text you know by heart — your name, a short sentence — and encode it. A free Morse code translator (https://morsezone.com/) will turn your text into dots and dashes instantly and play it back as audio, so you can hear the rhythm of each letter. Then try tapping it out yourself: short tap for a dot, long tap for a dash, pause between letters. Your first attempt will be slow and error-prone. Your tenth will be noticeably faster. That learning curve — clumsy to fluent in a few short sessions — is the same one switch users climb, and it is a useful reminder of what "easy to learn" actually means when the input channel is narrow.
If you build software, take the experiment one step further. Open your own product and try to complete its core task using only your keyboard. If you can do it, try it with a single switch — most operating systems have a switch-control mode built in. The gaps you find are your accessibility backlog, and they are more valuable than any audit report.
The two-button test
Here is a test worth running on every interface you ship: can a person using two buttons — and nothing else — complete the core task? Not eventually, not with heroic effort, but in a reasonable time, without errors that cost them their work.
Most products fail that test today. That is not a reason for guilt; it is a reason for a design principle. Morse code proves that two buttons are enough to say anything. The gap between that proof and your product is not a hardware problem. It is a series of choices: how many inputs you demand, how forgiving your timing is, how cheaply your interface fails, and whether you ever tested it with the mouse unplugged.
Two buttons. That is the whole input device. The rest is up to us.
Morse Zone (https://morsezone.com/) is a free online Morse code translator with audio playback, an alphabet chart, and practice tools. The author writes about Morse code, radio history, and the engineering lessons hidden in old protocols.
Top comments (0)