TL;DR: Modern computing sucks. Let's go back to the 90s, but redesign things more sensibly.

Many articles have been written on the deplorable state of modern computing and the world in general. The fact that somehow 8 GB of RAM in 2026 is considered "insufficient" is mindboggling, considering I was able to accomplish almost everything I needed of a computer on a Mac IIsi with mere megabytes of RAM. More troubling, however, is the utter inscrutability of modern computers. Not only has the software grown to inordinate complexity, so has the hardware. It is no longer possible to maintain a working mental model of how a CPU works, given branch prediction and the myriad levels of caching. I want to go back to a time when computing was personal, and computers were legible. Legible in the sense used in Seeing Like a State by James C. Scott, where it used to mean, roughly: observable, comprehensible, and controllable.

The Minimal 64x4 Home Computer is an example of a legible computing system. It is defined entirely using readily available ICs (7400 logic and a handful of memory chips). Its system architecture and microcode are easily describable. To me, this system nearly achieves perfect legibility. The least ideal aspect is its VGA subsystem; it uses non-standard VGA timing which many modern displays refuse to handle.

I am setting about a years long project to build legible personal computing systems for myself. As a start, in this article, I will outline the basic requirements. Then, I will move on to design and implementation. Note that I say "systems": there will likely be multiple incarnations of varying complexity or sophistication as I explore and understand what I actually need out of computing.

To begin with, I would like to list out some basic tasks that I expect to be able to perform:

1. Numeric calculations: Support for basic functions of a scientific calculator using floating point. Ideally, using BCD so that financial calculations are performed exactly.
2. Text editing and word processing: editing text documents, and possibly limited formatting support.
3. Spreadsheets: functionality similar to Visicalc or Lotus 123.
4. Bitmap drawing editor: A basic Macpaint-like capability.
5. Vector drawing editor: The ability to make diagrams. and possibly some architectural CAD or circuit schematic drawings.
6. Data export: Saving files and data to a micro SD card to interface with modern computing. Also: the ability to print to a serial or network printer.
7. Input methods: PS/2 keyboard and mouse support, possibly other HCI methods such as rotary encoders.
8. Backups and bootstrappability: Must have two "disk drives" so that "disks" can be duplicated.
9. Internet access: Possibly TCP/IP support to access rudimentary internet pages or alternative protocols like gopher.

This list is not meant to be exhaustive; additional functionality that interpolates these capabilities should be possible.

I think I should also be clear what is not required:

1. Multimedia: I am uninterested in video, sound, and games in general.
2. Color: I would much prefer a higher resolution bitmapped display if that means sacrificing color depth. I am perfectly fine with 1-bit graphics. I would also rather have color planes, such as is used in e-paper displays, rather than deal with the complexity of sub-8-bit pixel data.
3. Software compatibility: I fully expect to need to rewrite great swaths of the entire software stack in order to achieve my desired hardware architecture. Virtual machines such as uxn may alleviate some of the pains.

There are some high level architectural considerations that must be decided first. I think one aspect that is immediately fixed by this list is the need for fully bitmapped graphics; text mode a la the C64 will not suffice. Something more akin to the Macintosh is required. This requirement means that a full resolution framebuffer is also required, pigeon-holing us into a Macintosh-like architecture in which the graphics subsystem drives the clock and timing of the CPU and everything else.

The next major decision is the CPU to use, or more importantly, the bit width of the CPU. For the type of general purpose computing I am imagining, an 8-bit CPU with a 16-bit address space means a 64kb address space. The framebuffer will occupy approximately half of that unless banking is used, which does not leave much for actual computing use. Thus, 8-bit computing is largely out the window if we want to cover the entire list above.

However, since discovering the Minimal 64x4, I am somewhat wedded to its simplicity, and so I would like to continue exploring the limits of such an 8-bit platform lacking interrupts. At this point, the plan bifurcates; one path will use the Minimal 64x4 as a base and explore expansion cards and possibly hardware variations, while the other will use an integrated CPU.

The choice of >8-bit CPU that is well-understood and simple enough is fairly limited. The choices are going to be circa 80s era parts such as the 8086, 80286, 65C816, Z8000, 68000. Of this list, I am only really interested in the 68000. Partly due to its use in the original Macintosh, partly due to a long time personal interest in learning m68k assembly, and partly because of my past experience dealing with the memory segmentation of the '86 family.

Thus, it is decided:

1. Using the Minimal 64x4 CPU as a base platform, explore peripheral expansion to support items 1-6 in the requirements list. Possibly explore modifying the VGA section to support standard VGA timing with a 512x480 framebuffer (more on this later).
2. Design a Mac-like computer based on the 68000 (or 68010) with a modern peripheral set.

The next posts will expand on this, while a project page will track the conclusions.