CygnusEd

CygnusEd (commonly known as CED) is a text editor released in 1989 for The Amiga, made by ASDG Incorporated. It was fast. It was professional. It had multiple buffers, columnar editing, configurable menus, and — crucially — an ARexx port that turned it from a text editor into the nerve center of an automation empire.

riclib loved it to pieces.

“CED was the first editor I used that felt like it was mine. Not because I configured it — because I scripted it. ARexx turned CED from a tool into a platform. I built things with CED that CED was never designed to do, and CED never complained.”
— riclib, on the editor that started everything

The Editor

CygnusEd was, in its core function, a fast multi-buffer text editor. It loaded files instantly. It switched between buffers instantly. It searched instantly. On a machine with 1 MB of RAM and a 7 MHz processor, “instantly” meant what it said — there was no perceptible delay between pressing a key and seeing the result, because the editor was written by people who understood that the 68000 was fast enough if you didn’t waste its cycles.

This is a lesson that took the industry forty years to forget and that Zed is currently in the process of rediscovering.

CED had multiple open buffers before tabbed editing was a concept. It had configurable key bindings before the term “keybinding” was standardized. It had a command-line interface at the bottom of the screen for power users — not a terminal, but a direct line to the editor’s internals, where you could issue commands, chain operations, and automate repetitive tasks without leaving the keyboard.

It was, in essence, a smaller, faster, Amiga-native ancestor of the modal editing philosophy that vi had pioneered and Vim would later popularize on Unix. CED was not modal — it did not have separate command and insert modes — but it shared vi’s conviction that a text editor should respond at the speed of thought and that the keyboard is the only interface a serious user needs.

ARexx

ARexx was the Amiga’s inter-process communication language. It was a dialect of REXX — IBM’s scripting language for mainframes — ported to the Amiga and integrated so deeply into the operating system that any application could expose an ARexx port, and any ARexx script could talk to any application that did.

This was 1989. On the Amiga. A home computer.

CygnusEd had an ARexx port. Deluxe Paint had an ARexx port. The Amiga’s file manager had an ARexx port. The terminal had an ARexx port. The spreadsheet had an ARexx port. Every serious Amiga application had an ARexx port, because the Amiga’s culture expected applications to be automatable, scriptable, and capable of talking to each other.

This was inter-process communication — real, working, message-passing IPC — on a home computer in 1989. The year that Windows 3.0 would ship with DDE, a technology so unreliable that “DDE” became synonymous with “try it and pray.” The Amiga had already solved the problem. The Amiga had solved it with a scripting language that any teenager could learn.

“In 2026, developers spend weeks integrating two applications using REST APIs, JSON schemas, authentication tokens, and rate limiters. In 1989, on the Amiga, I connected CED to Deluxe Paint with six lines of ARexx. The script sent text to CED, formatted it, sent coordinates to Deluxe Paint, and Deluxe Paint drew it. The two programs talked to each other because they both had ARexx ports and ARexx ports were how programs talked to each other. It was not revolutionary. It was obvious. It was what computers were supposed to do.”
— riclib, on the Amiga’s integration model

The Slide Business

There was an agency in Lisbon that made presentation slides for multinationals. Quarterly sales kickoffs. Annual results. The kind of presentations where executives stand in front of a room and point at numbers going up. Before PowerPoint, these slides were composed by hand — physically, from stickers and transfer lettering and careful arrangement on card stock, then photographed.

The agency had a better idea. They painted the frame of an Amiga monitor matte black, displayed the slide on screen, and photographed it. A computer-generated slide, captured through a camera, projected as a 35mm slide. The Amiga’s display was the layout tool. The camera was the output device.

riclib made the slides. Five euros per slide. By hand, in Deluxe Paint, pixel by pixel, text by text, correction by correction.

The corrections were the problem.

A quarterly sales kickoff has numbers. Numbers change. Titles change. The VP of Southern Europe decides the bullet points should be reworded. The chart needs updating. Every correction meant opening Deluxe Paint, finding the text, erasing it, redrawing it, re-aligning it, re-checking it. At five euros per slide and dozens of slides per presentation, the money was good. The manual labour was not.

So riclib invented a markup language.

Not a formal language. Not a specification. A format — something like what Markdown would become fifteen years later — where you could describe a slide’s content in text: title, subtitle, bullet points, layout hints. The text lived in CED. An ARexx script read the format, parsed the structure, and sent commands to Deluxe Paint III or IV to render the slide — set the background, position the title, draw the bullet points, apply the colour scheme.

Change a number in CED. Re-run the script. Every affected slide regenerates. The VP of Southern Europe changes his mind again. Change the text. Re-run the script. Done. What had been an hour of manual pixel work per correction became a ten-second edit in a text file.

This was not PowerPoint. This was better than PowerPoint, because it was automated. PowerPoint — which existed but was a Macintosh application for people with corporate budgets — was still manual in 1989. A teenager in Lisbon had built a more automated presentation pipeline than Microsoft’s dedicated software, from a text editor, a paint program, and a scripting language.

The Anti-Aliasing Problem

There was one issue. Resolution.

The Amiga’s display was low resolution by modern standards — 320x256 in PAL, 640x256 in hi-res mode. For text on screen, viewed on the Amiga’s original monitor, this was fine. The Commodore 1084 was not a sharp monitor. It was, charitably, a fuzzy monitor. The fuzziness was a feature — it smoothed the jagged edges of low-resolution pixels into something that looked, if you squinted with the right attitude, almost anti-aliased.

riclib tried a better monitor. A sharper display. The result was worse. Every pixel edge was now crisp, visible, jagged. The staircase pattern on diagonal lines and curved text that the Commodore monitor had gently blurred into acceptability was now rendered in brutal clarity. The “natural anti-aliasing” of the fuzzy monitor — the accidental smoothing of a display that was too blurry to show individual pixels cleanly — was gone.

The original monitor went back on the desk. The fuzzy image, photographed through a camera onto 35mm film, looked professional. The sharp image looked like a computer. The clients were paying for professional, not for computer.

“The best anti-aliasing algorithm of the late 1980s was a slightly out-of-focus CRT. The Commodore 1084 shipped with this algorithm built in. Commodore did not know this was a feature. The photographer’s camera did not care.”
— The Lizard, on accidental engineering

The End

Commodore did not improve the Amiga’s display resolution. PowerPoint arrived on platforms that mattered to corporations. The agency eventually moved on. The slide business ended.

But one year of riclib’s university studies was paid for by slides rendered in Deluxe Paint, automated by ARexx scripts written in CygnusEd, displayed on a monitor with a matte black frame, photographed onto 35mm film, and projected in boardrooms where executives pointed at numbers going up.

The executives did not know the slides were made on a home computer. The executives did not know the home computer was running a paint program controlled by a text editor controlled by a scripting language invented by IBM for mainframes. The executives did not know any of this, and they did not need to know, because the slides looked professional, and looking professional was the entire point.

“A tool should not constrain what you can build. A tool should be a component in a system you design yourself. CED was a text editor. Deluxe Paint was a paint program. ARexx was the glue. Together, they paid for university.”
— riclib, on the real measure of a toolchain

The Legacy

CygnusEd is gone. ASDG is gone. The Amiga is gone — or rather, the Amiga is in the state of not-quite-gone that retrocomputing preserves, where the hardware lives in attics and the software lives in emulators and the community lives on forums that are themselves relics.

But what CED taught persists:

A text editor is a platform. Not because it has plugins — CED did not have plugins in the modern sense — but because it has a scripting interface that lets the user connect it to other tools. CED’s ARexx port was the same insight that Vim’s Vimscript embodied, that Emacs’ Lisp embodied, that VS Code’s extension API embodies: the editor is not the destination, the editor is the hub.

Automation is not a feature, it is the point. The slide business existed because ARexx made it possible to connect two programs that had no knowledge of each other. The programs didn’t need to know. The script knew. The user knew. The tools were components. This is the Unix philosophy, arrived at independently, on a Commodore, by a teenager in Lisbon who was tired of redrawing bullet points by hand.

Speed is a feature. CED was fast on a 7 MHz processor with 1 MB of RAM because the developers respected the machine’s constraints. Zed is fast on a 4 GHz processor with 32 GB of RAM because the developers respect the user’s time. The lesson is the same. The machines changed. The lesson didn’t.

Measured Characteristics

Year released:                           1989
Platform:                                Amiga (AmigaOS)
Developer:                               ASDG Incorporated
Key feature:                             ARexx port (inter-process scripting)
Scripting language:                      ARexx (REXX dialect, built into AmigaOS)
Speed:                                   instant (on a 7 MHz 68000 — real instant, not marketing instant)
Multiple buffers:                        yes (before tabs existed)
riclib's feeling about it:               loved it to pieces
The slide business:                      CED + Deluxe Paint III/IV + ARexx
The client:                              agency making slides for multinationals' quarterly kickoffs
Previous method:                         stickers and transfer lettering, composed by hand
Amiga method:                            display on screen, photograph the monitor
Monitor preparation:                     frame painted matte black
Price per slide:                         5 euros
The markup language:                     invented before Markdown, for the same reason
What it automated:                       corrections (the VP always changes his mind)
Anti-aliasing solution:                  the Commodore 1084's natural fuzziness
Better monitor result:                   worse (sharp pixels, visible jaggies)
University studies paid for:             one year
Client awareness of the toolchain:       zero (this was a feature)
IPC model:                               ARexx message passing (1989, on a home computer)
Equivalent IPC in 2026:                  REST APIs, JSON, OAuth, rate limiters, three meetings
Lines of ARexx to connect two apps:      ~6
What killed the business:                Commodore didn't improve resolution + PowerPoint arrived

See Also

• The Amiga — The machine CED ran on. Everything about CED makes more sense in the context of what the Amiga was.
• vi — The editor philosophy CED shared: fast, keyboard-driven, professional. Different lineage, same conviction.
• Vim — CED’s ARexx port anticipated Vimscript’s purpose: make the editor scriptable so users can build what the developer didn’t imagine.
• Zed — The modern editor that is rediscovering CED’s speed. CED was instant on 7 MHz. Zed is instant on 4 GHz. The bar hasn’t moved. The hardware has.
• VS Code — The editor that took thirty years to achieve what CED had in 1989: a scripting interface that connects the editor to other tools. VS Code uses JavaScript. CED used ARexx. ARexx was better.
• Deluxe Paint — The other half of the poor man’s PowerPoint. If CED was the brain, Deluxe Paint was the hands.
• Demo Scene — Where ARexx skills and CED familiarity led to building things that should not have been possible on the hardware.