Partner Shop
See more Console Classics stories on Google.
See more Console Classics stories on Google.
ZX Spectrum text editing gets a surprisingly capable upgrade with .paper, a tiny Z80-built utility featuring search, replacement, menus, and more.
A Little Editor With a Big Ambition
A text editor on the ZX Spectrum sounds modest until you remember the machine’s original limitations. Then .paper appears, weighing in at roughly 7 KB, and suddenly the idea feels far more impressive. This isn’t just a blinking cursor in a black void—it’s a practical editor with enough tools to make real file work comfortable.
Created by Spectrumeer shrek128, the same developer behind the Bow Commander file manager, .paper is designed for systems using DivMMC or a compatible interface running esxDOS. It launches from BASIC and is written entirely in Z80 assembly language, which goes a long way toward explaining how much functionality fits into such a small package.
The name is deliberately understated. “.paper” sounds like a utility you might find tucked away on a floppy disk, its documentation printed in a tiny monochrome manual. That plainness suits the program. It doesn’t try to turn the ZX Spectrum into something it isn’t. Instead, it works with the machine’s character-based nature and makes the most of it.
A 64-Character View That Makes Sense
The working area displays 22 lines, each stretching to 64 characters. That gives the editor a useful amount of text on screen while staying within the familiar visual rhythm of the Spectrum.
Text wraps automatically, so long lines don’t simply disappear off the edge of the display. This matters more than it might seem. Manual line management is one of those small chores that quickly becomes irritating, especially when the editor is being used for notes, configuration files, or other plain-text tasks.
The interface also includes drop-down menus. That’s a notable touch on a platform where many utilities rely almost entirely on keyboard shortcuts or terse command prompts. Menus make the available tools easier to find, particularly when returning to the program after some time away.
I initially expected .paper to feel like a stripped-down emergency tool because of its tiny file size. That first impression doesn’t really survive contact with the feature list. It remains compact, certainly, but it isn’t bare-bones.
Search, Replace, and the Useful Little Details
The core editing tools are where .paper starts to feel genuinely practical. It supports case-insensitive searching, meaning the editor can locate text without demanding an exact match between uppercase and lowercase characters.
That sounds ordinary on a modern computer, but it’s precisely the sort of convenience that separates a usable editor from a technical curiosity. You can search without worrying whether a word was typed as “Config,” “config,” or “CONFIG.” The program handles the distinction for you.
There’s also a mass replacement function. Again, this is a feature that can save a surprising amount of time. Changing repeated text manually is the kind of task that turns a five-minute edit into a small endurance test. On a system with limited memory and a simple display, reducing that repetition is especially welcome.
Other listed functions include:
- Deleting lines from a document
- Saving a file under a new name
- Accessing built-in help for keyboard shortcuts
- Working with drop-down menus
- Automatically wrapping text
- Searching without case sensitivity
- Replacing multiple instances of text
The individual features aren’t flashy, but they fit together sensibly. .paper seems less interested in showing off than in removing the annoying friction around everyday text editing. That’s a good design instinct.
The Memory Trick Behind the Program
Here’s the clever part: .paper uses the unused area of BASIC memory between the workspace and the stack.
On a freshly powered-on machine, nearly 40 KB is available in that region. A BASIC program already loaded into memory reduces the amount of room left for the editor, of course. Still, the approach allows .paper to operate on both 48K and 128K ZX Spectrum models.
The editor requires approximately 2 KB of free memory. That is a remarkably small footprint, though the exact amount available will depend on what has already been loaded. This is one place where expectations need to stay realistic. It isn’t a modern editor with an unlimited canvas; the available working space is tied closely to the current memory situation.
That memory strategy also gives the program a distinctly old-school character. Instead of demanding a particular upgraded configuration, .paper looks for the space the machine already has. It’s a practical compromise, and one that feels very much in the spirit of home-computer software from the era.
I’m not completely certain how comfortable very large files would be in every setup, since the available memory changes once a BASIC program is present. The important point is that the editor does not require a 128K model specifically. Its stated compatibility with both 48K and 128K machines makes it considerably more accessible.
Installing .paper Under esxDOS
Installation is straightforward, provided the system is already using an esxDOS-compatible storage setup.
The .paper file must be copied into the /BIN directory on the storage device. Once it is there, the editor can be launched from BASIC with the .paper command.
The command is followed by the name of the file, or by its complete path. In simplified form, the process looks like this:
.paper filename
For a file stored in another directory, the full path can be supplied instead. That approach keeps the utility familiar to anyone who has used command-line tools on a classic computer, while the editor itself provides a more approachable environment once the file is open.
The installation instructions are refreshingly short. There’s no elaborate setup routine, no maze of configuration screens, and no need to turn the ZX Spectrum into a different machine. Copy the file, start the command, provide the filename, and begin editing.
That simplicity is one of the program’s strongest qualities. The editor feels like a utility that belongs on the system rather than an oversized demonstration of what the hardware might theoretically do.
Where .paper Fits in a Classic Setup
The most convincing use case is plain-text work where a full desktop computer would feel excessive. Notes, small text files, configuration data, and quick edits all fit naturally into the editor’s design.
The 22-line display keeps the current material visible without making the interface feel crowded. Automatic wrapping makes longer passages easier to read, while search and replacement reduce the amount of tedious cursor movement. The menus and shortcut help add a little structure to what could otherwise become a collection of commands to memorize.
There is a mild limitation here, though: the program’s usefulness depends on having the right storage interface and esxDOS environment already available. That isn’t a flaw in .paper itself, but it does mean the editor is aimed at a specific kind of ZX Spectrum setup rather than every machine sitting in a cupboard.
For that audience, the fit is much better. It’s small, purposeful, and compatible with both major memory configurations mentioned in its documentation. The program doesn’t promise to be a general-purpose word processor, and it doesn’t need to be one.
Why the Tiny Size Matters
A utility measuring about 7 KB feels almost quaint now, but size remains part of the appeal. Small software is easier to keep on a storage device, easier to launch, and less intimidating to understand.
There’s also a certain satisfaction in seeing a useful tool assembled from such a constrained environment. The feature list suggests careful prioritization: editing first, then the conveniences that make editing less tiresome. Search, replacement, line deletion, renamed saves, menus, and shortcut help are exactly the kind of functions that earn their place.
The assembly language implementation reinforces that efficiency. Z80 assembly is not a casual choice, and in this case it matches the target hardware neatly. The result is a program that feels tuned to the machine rather than merely ported onto it.
I had expected the small file size to come with obvious compromises, but the balance is more thoughtful than that. .paper still has limits, and the memory model matters, yet the editor appears to understand what a Spectrum user actually needs from a compact text tool.
Getting the Editor
The .paper release is available through itch.io, where the downloadable version can be found here:
Before launching it, place the .paper file in the /BIN directory of the esxDOS storage device. From there, invoke it through BASIC and provide the target filename or full path.
That process keeps the entire experience suitably direct. No elaborate ceremony—just a small file, a command, and the familiar glow of a Spectrum display waiting for text.
Conclusion
.paper is a modest utility with unusually sensible priorities. It doesn’t attempt to overwhelm the ZX Spectrum with features; instead, it adds the tools that make text editing less awkward while respecting the machine’s memory and screen limitations.
The result is compact, practical, and pleasantly focused. Search, replacement, automatic wrapping, menus, line deletion, renamed saves, and shortcut help may sound basic by modern standards, but on a classic Spectrum setup they add up to a genuinely useful editor. Would you keep .paper on your esxDOS drive for quick notes and file edits?
FAQ
- What is .paper?
.paper is a small text editor for the ZX Spectrum. It is approximately 7 KB in size and includes tools such as automatic text wrapping, case-insensitive search, mass replacement, line deletion, and file renaming during saves. - Which ZX Spectrum models can run .paper?
The editor is designed to work on both 48K and 128K ZX Spectrum models, provided the required storage and esxDOS-compatible environment are available. - How much free memory does .paper need?
The editor requires approximately 2 KB of free memory. It uses unused BASIC memory located between the workspace and the stack. - How do you install .paper?
Copy the.paperfile into the/BINdirectory on an esxDOS storage device. Then launch it from BASIC with the.papercommand, followed by a filename or full file path. - Does .paper support search and replacement?
Yes. It includes case-insensitive searching and a mass replacement function, along with line deletion, automatic wrapping, menus, and keyboard shortcut help.
Subscribe to the newsletter for more carefully chosen classic-computing stories and practical retro discoveries.
