Amiga ARexx vs AppleScript: a forgotten battle in computer automation

Before automation became a buzzword, the Amiga and the Macintosh were already making computers do the boring work. AppleScript promised Mac users control in near-English, while ARexx gave Amiga owners something more direct: a way for applications to talk to each other. One became famous. The other became a cult favourite. But fame is not the same as foresight. On the Mac, automation felt like a clever extra. On the Amiga, it felt closer to the machine’s personality: fast, practical, slightly eccentric, and happiest when several things were happening at once. By the time most computer users discovered automation, they had already lost patience with it. They had spent years renaming files one by one…

The Mac won the market. The Amiga may have understood automation better.

Before automation became a buzzword, the Amiga and the Macintosh were already trying to make computers do the boring work. AppleScript promised Mac users automation in near-English. ARexx gave Amiga users something less polished but more direct: a way for applications to talk to each other. One became famous. The other became a cult favourite. But the Amiga may have understood the spirit of automation better.

By the time most computer users discovered automation, they had already lost patience with it. They had spent years renaming files one by one, opening the same menus in the same order, copying data from one application to another like underpaid office monks, and whispering unprintable things at progress bars. Then someone would say, “You know, you can automate that,” and the room would divide instantly into two groups: the people who saw salvation, and the people who heard the word “script” and suddenly remembered an urgent appointment elsewhere.

In the late twentieth-century desktop wars, two machines offered unusually ambitious answers to that problem. On the Macintosh, Apple gave users AppleScript, an automation language that tried to make programming look like written English. On the Commodore Amiga, users got ARexx, a leaner, stranger, more direct system that let programs send commands to one another through the Amiga’s already lively message-passing culture. One became famous. The other became beloved. That distinction matters.

AppleScript is the survivor, still present in the modern Mac’s automation toolkit alongside Automator, Shortcuts, JavaScript for Automation, shell scripts, and third-party tools. ARexx, by contrast, lives mainly in the Amiga world: retrocomputing, classic operating system maintenance, emulation, niche productivity, hobbyist development, and the stubbornly charming places where computing still smells faintly of warm plastic and solder. But fame is not the same as quality. Ask any pop chart.

The argument for ARexx is not that it conquered more desks. It did not. The argument is that, on the Amiga, automation felt less like a feature and more like a philosophy. It was part of the machine’s personality. The Amiga did not merely run applications. At its best, it encouraged them to cooperate, gossip, and occasionally take orders from a script like a well-trained newsroom staff after the third coffee.

The world before “workflow”

To understand why ARexx felt so advanced, you have to remember what personal computing looked like when it arrived. Many home computers were still fundamentally one-thing-at-a-time machines. You launched a program, used it, quit it, launched another program, and prayed that your floppy disk did not develop an exciting new personality. Serious automation existed, of course, but much of it belonged to mainframes, minicomputers, Unix workstations, or business systems with users who knew exactly what a command line was and did not require emotional support before using it.

The Amiga was different. From the mid-1980s, it offered pre-emptive multitasking, strong multimedia hardware, and an operating system that made separate tasks feel unusually alive beside each other. More importantly for our story, AmigaOS had a built-in culture of inter-process communication. Its message ports allowed tasks and programs to communicate in a way that made software cooperation feel natural rather than bolted on afterwards. That sounds dry, but so does “fermentation,” and look what that did for beer.

ARexx fit beautifully into that world. It was the Amiga version of IBM’s REXX language, but on Commodore’s machine it became something with its own character. It was not just about making one program repeat a command. It was about orchestrating several programs into a workflow. A good ARexx-aware application could expose a command port. A script could address that port, send commands, receive results, and move on to the next program. In practice, this meant your text editor, paint package, terminal, database, video tool, music software, or desktop utility could become part of a larger chain. The user became less of a button-pusher and more of a conductor. Sometimes the orchestra was magnificent. Sometimes the trombone player fell into the timpani. But at least you had a baton.

AppleScript: the elegant butler who keeps asking what “it” means

AppleScript arrived later, and with a very Apple idea behind it: what if automation could read like ordinary language? The ambition was admirable. AppleScript wanted to let users say things such as “tell application Finder to open this folder” or “tell QuarkXPress to process these documents,” and have the Mac obey.

In theory, this was glorious. In practice, AppleScript could be both powerful and maddening. Its English-like syntax made demos look friendly, but real scripts had a way of becoming oddly ceremonial. You did not always feel like you were programming. Sometimes you felt like you were negotiating with a very literal hotel concierge. “Would sir care to specify whether sir means the document object, the file alias, the selection, the front window, or the blessed metaphysical essence of the image?”

ARexx rarely tried that trick. It was not pretending to be English. It was a scripting language, and it looked like one. That made it less welcoming to absolute beginners, perhaps, but also less deceptive. It did not lure you into the room with tea and then hand you a grammar problem wearing a waistcoat.

Why Amiga users loved ARexx

The Amiga was a machine for people who liked making machines do things they were not explicitly sold to do. Musicians used it. Video people used it. Demoscene coders used it. Desktop publishers, hobbyists, BBS operators, experimenters, and people with alarming cable collections used it. It attracted the sort of owner who would look at a commercial program and think, “Nice, but can I make it answer to me?”

ARexx rewarded that attitude. If an application supported ARexx properly, it did not sit there like a sealed appliance. It became programmable from outside. You could use one tool for what it did best, pass the output to another, have a third tidy up the result, and then make the whole sequence repeat without your hand hovering over the mouse like a nervous helicopter. That was particularly powerful on the Amiga because so many of its creative uses involved pipelines. Imagine preparing a batch of images, generating text, converting formats, updating a project file, or coordinating utilities in the background. Today we would call that “workflow automation” and sell it with a subscription plan and a tasteful gradient logo. On the Amiga, it was Tuesday.

There is a journalistic danger here: romantic overcorrection. Because the Amiga lost commercially, it is tempting to make it perfect in memory. It was not. ARexx support depended on developers. If a program did not expose a useful ARexx port, the magic stopped at the door. Documentation quality varied. Error handling could be cryptic. And no amount of scripting elegance could change the fact that Commodore, as a business, had the strategic steadiness of a shopping trolley with one locked wheel. But the core idea was superb. Applications should be controllable. Users should be able to join them together. The operating system should not treat every program as a private island with border control and a small navy.

The Mac had scale; the Amiga had intimacy

AppleScript’s greatest advantage was not syntax. It was survival. The Mac ecosystem continued, professional software vendors supported it, and automation found strong footholds in publishing, prepress, design, administration, and office workflows. AppleScript may never have been universally loved, but it solved real problems. In many Mac-heavy workplaces, especially those dealing with documents, layouts, images, and repetitive production jobs, it became the strange little engine that kept things moving.

That is the realistic part of the comparison. AppleScript mattered because it had users, commercial support, and a continuing platform. ARexx was arguably cleaner and more natural to its host operating system, but its fate was tied to the Amiga’s fate. When Commodore collapsed and the platform fragmented, ARexx became a brilliant mechanism inside a shrinking house.

Even now, the contrast is striking. The Mac remains a current commercial platform, with multiple overlapping automation systems. The Amiga remains a cherished, active, but specialist world. That does not diminish ARexx’s design achievement. It simply puts it in the correct frame. The Mac had scale. The Amiga had intimacy. AppleScript worked inside a large professional ecosystem. ARexx worked inside a smaller machine culture where users often felt personally connected to the system. On the Mac, automation could feel like a useful facility. On the Amiga, it felt like the computer was quietly inviting you behind the curtain.

A difference in temperament

The deeper difference between ARexx and AppleScript is cultural. AppleScript came from Apple’s long-standing desire to humanise computing. It tried to make automation sound approachable. That instinct is noble. Computers should not require users to wear a ceremonial Unix beard before they can save time. But AppleScript also showed the danger of making code look too much like prose: it can become less precise while still remaining unforgiving. That is the worst of both worlds, like a friendly dog that corrects your tax return.

ARexx came from a more hackerish, workstation-like sensibility. It assumed the user was willing to learn a scripting language in exchange for real control. It was not as cuddly, but it was honest. The Amiga did not pat you on the head and say, “Don’t worry, this is just like English.” It said, “Here is a powerful message-driven system. Try not to crash anything important.” This gave ARexx a particular kind of charm. It respected the user. It did not hide the machinery; it handed you a spanner. That approach is not right for everyone, but for the Amiga’s audience it was intoxicating.

The best Amiga software often felt expandable, personal, and slightly subversive. ARexx amplified that. It let users add features that developers had not planned. It let small utilities become part of bigger systems. It made the computer feel less like a finished consumer product and more like a workshop. AppleScript, meanwhile, often felt like a grand civic system: more formal, more architected, more dependent on official dictionaries and application compliance. At its best, it let complex professional workflows run across major Mac applications. At its worst, it made you wonder whether the Finder had taken a vow of ambiguity.

Today’s automation landscape: everyone rediscovered the old argument

The funny thing is that modern computing has come back around to the question ARexx answered so well. Users now expect automation everywhere. They want APIs, plug-ins, Shortcuts, Zapier-style integrations, shell hooks, app intents, command palettes, no-code tools, webhooks, and AI agents that can move data between services without needing a biscuit and a lie-down. The terminology has changed. The principle has not. We still want programs to talk to each other. We still want repetitive work to disappear. We still want software to expose handles, not just buttons.

On the Mac, automation is powerful but fragmented. AppleScript remains useful, Automator still exists, Shortcuts has become the more consumer-friendly automation layer, shell scripting remains indispensable, and JavaScript for Automation sits there like an invited guest whom everyone keeps forgetting to introduce properly. The result is capable, but not exactly tidy. The modern Mac automation toolbox sometimes looks as if three generations of handymen have each added their favourite wrench and nobody has labelled the drawers.

The Amiga’s automation story, oddly, is cleaner precisely because it is smaller. ARexx remains tied to a world where the machine is understood as a cooperating set of components. It is not trying to be a universal cloud automation platform. It is not trying to schedule your smart lights, parse your email, and ask a large language model to apologise to your dentist. It is trying to make Amiga programs work together. That modesty is part of its elegance.

The developer question

There is one unavoidable point in AppleScript’s favour: getting developers to support automation is hard. It was hard on the Mac. It was hard on the Amiga. It remains hard now. A scripting system is only as useful as the applications that expose meaningful commands. Apple’s model required developers to define scripting dictionaries and respond properly to Apple events. Amiga developers had to provide ARexx ports and useful command sets. In both worlds, the best applications became dramatically more powerful when they embraced scripting. The mediocre ones did the minimum. The worst ones pretended the outside world did not exist, which is a bold position for software running on a multitasking operating system.

The Amiga’s advantage was that ARexx felt culturally aligned with its developer and power-user community. The kind of developer writing serious Amiga software often understood that users wanted control. The kind of user buying serious Amiga software often expected it. That shared expectation produced some wonderful results.

Apple had the harder mass-market problem. It had to make automation work for ordinary users, professional users, and major commercial vendors. AppleScript’s English-like style may have been awkward, but it was also a brave attempt to bring automation to people who did not think of themselves as programmers. That effort deserves respect, even from those of us who suspect AppleScript’s grammar was designed during a long lunch.

So which was better?

If “better” means broader historical impact, AppleScript wins. It reached more users, lasted longer in the mainstream, and became part of professional Mac workflows for decades. It survived architecture changes, operating system transitions, and Apple’s own periodic attempts to reinvent how users automate tasks. Like an old printer in the corner of an office, it kept working long after everyone forgot who installed it.

If “better” means conceptual fit with the operating system, ARexx wins. It belonged to the Amiga in a way AppleScript sometimes struggled to belong to the Mac. ARexx sat naturally on top of AmigaOS’s message-passing, multitasking personality. It made the system feel open and cooperative. It did not need to pretend to be English because the Amiga did not need that kind of theatre. It needed a way for applications to answer the phone.

If “better” means elegance for power users, ARexx has the stronger claim. Its model was straightforward: applications expose ports; scripts send commands; workflows emerge. There is something beautifully mechanical about that. You can almost hear the relays clicking, even though there are no relays, and someone on an Amiga forum will now write 900 words explaining why that analogy is technically inaccurate.

The verdict: AppleScript got the career; ARexx had the soul

The fairest judgement is this: AppleScript was the more successful product of history, but ARexx was the more Amiga-like expression of what automation should feel like. AppleScript deserves its place. It was ambitious, useful, and surprisingly durable. It helped Mac users automate real work, particularly in publishing, design, administration, and document-heavy environments. It is still part of the Mac’s automation toolbox, even if that toolbox now looks crowded, layered, and occasionally unsure of itself.

But ARexx remains special because it captured a better instinct: that personal computers should be personal not merely in appearance, but in behaviour. A user should be able to reshape the machine. Applications should not be sealed boxes. The system should invite combination, extension, and control.

That is why ARexx still matters. Not because everyone should abandon modern Macs and return to a beige desk with a tank mouse, although there are worse lifestyle choices. It matters because the Amiga saw something early: automation is not an accessory. It is a form of ownership. The Mac gave automation a long career. The Amiga gave it a mischievous grin, a command port, and the keys to the workshop. And if we are honest, that is the one we would rather have a beer with.