Cascade Made Letters Fall Down

Picture a quiet office in the late 1980s. The computers are big, heavy boxes with green glowing screens, and the words on those screens sit still, line by line, exactly where they were typed. Then, one ordinary day, something strange happens. A single letter near the top of the screen lets go. It slides slowly downward, past all the other letters, and lands at the very bottom. Then another letter follows it. And another. Soon the whole screen has a small, silent rain of letters falling through it, gathering into a soft pile at the bottom edge, like sand settling in the corner of an hourglass. Nobody has touched the keyboard. Nothing has been deleted. The words are simply… falling.

The little ghost behind this gentle chaos had a name: Cascade. It is one of the oldest computer viruses ever known, and in a long series of dangerous and destructive programs, it stands out for a simple reason. It barely did any harm at all.

What the Cascade virus actually is

Cascade was a computer virus — a small program written to copy itself from place to place without being invited. It was first seen in Germany in the autumn of 1987, in the early days of home and office computing. Back then, most ordinary computers ran a simple text-based system called DOS. There were no colourful windows, no mouse clicks on friendly icons. You typed commands, the computer obeyed, and everything on the screen was made of plain characters: letters, numbers and symbols sitting in rows.

Cascade was built to live inside the program files of those DOS computers — the files ending in .COM, which were the everyday working programs of the time. Once it was hiding inside a program, it waited quietly. It did not shout. It did not crash the machine. It simply sat there, invisible, and at certain moments it woke up and performed its one famous trick.

The falling letters trick

When Cascade decided to perform, it reached into the text on the screen and loosened the letters’ grip. One by one, characters lost their hold on their line and slid down the screen, gathering in a heap along the bottom edge. The effect looked like a tiny waterfall of words, or a slow shower of falling leaves made of type.

The strangest part is that the computer usually kept working. A person typing a letter or adding up numbers in a spreadsheet could watch characters rain gently past their work and still carry on. The screen looked haunted, but the machine underneath was unharmed. Cascade deleted nothing. It stole nothing. It changed no files into rubbish and sent no secrets anywhere. Its entire payload — the thing it was built to do — was this small, dreamy piece of mischief.

I find something almost sweet about a virus whose grand plan was to make the alphabet slip off the screen for a moment, because it reminds us that even strange and unwanted software can have a human sense of humour hiding inside it.

How Cascade spread from computer to computer

In 1987 there was no web to browse and no app store to visit. Programs travelled the slow way: on floppy disks, handed from one person to another. A friend would lend you a disk with a useful tool on it. A colleague would copy a program for you so you did not have to buy your own. Disks moved from office to office and home to home, and nobody thought twice about it.

Cascade rode along inside those shared programs. When someone ran an infected .COM file, the virus woke up, copied itself into the computer, and from there into other clean program files on that machine. The next time that person shared a program on a floppy disk, Cascade quietly went travelling again, tucked inside a perfectly normal-looking file.

This is how something like Cascade can reach an ordinary person, then and now. It does not need a dramatic break-in. It only needs one trusted moment: a program accepted from a friendly hand, a file opened without asking where it came from. The program can be completely real and completely useful — and still carry an uninvited passenger inside it. That is the quiet heart of this whole story: an unwanted program can live inside a genuine one, and the person sharing it may have no idea it is there.

The damage story — honestly, there is almost none

Most virus stories come with a heavy bill: money lost, files destroyed, businesses closed for days. Cascade’s damage story is, honestly, almost empty, and that smallness is exactly what makes it charming.

The real damage was this: people were startled. Work was interrupted while someone stared at their screen and wondered whether the computer was breaking. Some time was lost to confusion, to calling a colleague over, to switching the machine off and on again and finding the letters still behaving oddly. That is roughly the whole of it. No fortunes vanished. No records were wiped out. No one was locked out of their own work forever.

Yet the legend of the falling letters grew far bigger than the virus itself. In the early years of personal computing, most people had never seen software do something it was not told to do. Watching your own screen disobey you — even gently, even playfully — was a new and unsettling feeling. Cascade became one of the first viruses ordinary people talked about, not because it hurt them, but because it showed them, for the very first time, that a program could have a secret life of its own.

The hidden trick that changed virus history

Underneath the joke, Cascade left one serious mark on computing history, and it is easy to miss because it cannot be seen on any screen.

Cascade was the first known virus to scramble its own body — to “encrypt” itself, in the language of security experts. Think of it this way: early antivirus tools worked by reading a virus’s code, much as you would read a note, and learning to recognise it the next time it appeared. Cascade folded its note in a cipher. Most of its body was scrambled into nonsense, so the early tools could not simply read it and know it at a glance. Only a tiny piece of the virus stayed readable, the small part whose job was to unscramble the rest once it was safely inside a machine.

It was a clever hiding trick, and it was born inside a harmless prank. That is the sobering part. Once the idea existed, harmful malware copied it for decades afterwards. Generation after generation of far more dangerous programs learned to cloak and scramble themselves, making them harder for security tools to spot. A joke program from 1987 quietly invented one of the main disguises that serious criminals still use today.

Protecting yourself from programs with passengers

Cascade is long gone, but the road it travelled is still open, and the defence is not complicated. It rests on one gentle habit: knowing where your programs come from.

First, treat programs from unknown hands with care. A file shared by a friend, found on an old disk, or offered by a stranger may be perfectly genuine — but you cannot see what is riding inside it. If you do not know the source, the safest answer is not to run it.

Second, remember that a real program can carry an unreal passenger. The tool itself might work exactly as promised while something unwanted settles into your machine alongside it. “It works fine” is not the same as “it is clean”, and Cascade is the proof — its infected programs worked fine too, right up until the letters started falling.

Third, keep your guard up with anything copied, borrowed or passed along informally. In 1987 that meant floppy disks slipped from drawer to drawer. Today the shapes of sharing have changed, but the lesson has not: the more casually a program changes hands, the less anyone has checked what is inside it.

Finally, take strange behaviour seriously, even when it looks harmless. Falling letters seemed like a joke, and in that one case it mostly was. But odd behaviour is a message from your machine that something uninvited may be present — and the next uninvited guest may not be there to entertain you.

Common questions

Did the Cascade virus delete people’s files?

No. Cascade deleted nothing and stole nothing. Its only real action was its famous display trick, making characters on the screen slide down and pile up at the bottom. People lost a little time and a little peace of mind, but their work stayed intact.

How did Cascade get onto a computer?

It hid inside ordinary DOS program files, the .COM files of the era, and travelled on shared floppy disks. When someone ran an infected program, Cascade copied itself into the machine and then into other program files, ready to travel onward with the next shared disk.

Why is Cascade important if it was harmless?

Because it was the first known virus to scramble — or encrypt — its own code so early antivirus tools could not easily read it. That cloaking trick was later copied by harmful malware for decades, which makes this small joke program a genuine turning point in computer security history.

Could a harmless program still be dangerous today?

The program itself might be gentle, but anything uninvited on your machine proves a door was left open. The same quiet road that carried Cascade can carry something far worse. That is why knowing where your programs come from still matters more than almost any other safety habit.

When and where did Cascade appear?

It was first seen in Germany in the autumn of 1987, as reported in accounts of early computer viruses. From there it spread the way everything spread in those days: slowly, on floppy disks, inside ordinary programs passed between ordinary people.

Sources

• Wikipedia — Cascade (computer virus): https://en.wikipedia.org/wiki/Cascade_(computer_virus)