I have been building three terminal projects: Goblin Mosh, GoblinView, and Goblin Purrfect.

At first glance, this might look like an elaborate attempt to recover 1989.

There is a certain amount of that. I miss WordPerfect 5.1. I miss being able to type equations about as quickly as a professor could write them on the board. I have fond memories of Hercules displays and the plasma display on my IBM P75. Amber remains an excellent color for a computer.

But there are two goals here.

The first is practical: build a modern, useful version of Mosh that carries modern terminal features, and a terminal window manager with the session persistence of tmux, overlapping windows, and proper handling of graphics and input. I want the features available at my local terminal to remain useful when the application is remote or inside a multiplexer.

The second is a question:

What would the world look like if Windows had never become popular and the terminal had remained king?

Not if computing had stopped in 1989. If terminal software had kept evolving.

We would still have Unicode, high-resolution displays, good fonts, mice, images, fast processors, and networks. The interesting question is what applications would look like if the terminal had remained the primary place we used those things.

These three projects are my attempt to explore that question by building software I actually want to use.

Goblin Mosh: Keep the Connection, Bring the Features

Mosh already has a very good central idea: a remote session should survive an unreliable connection, and typing should not require waiting for a round trip across the planet. Its roaming, predictive local echo, and screen-state synchronization are worth keeping.

Goblin Mosh is my fork. The aim is to keep those properties while making the connection useful for modern terminal applications.

Modern terminals can do considerably more than display characters in a fixed grid. The kitty protocol extensions cover graphics, richer keyboard events, text sizing, clipboard operations, drag and drop, and more. Those capabilities need a path through the tools between an application and the terminal displaying it.

For Mosh, that is not simply a matter of forwarding every escape sequence. Mosh synchronizes state. An image and its placement need to become part of the state the two ends understand.

Goblin Mosh's static Kitty graphics path does that: moving an existing image does not require sending its pixels again. The broader work includes modern input and clipboard handling, native terminal scrolling, and graphics support across the connection. Kitty and Sixel belong in that design, with capabilities negotiated rather than assumed.

Bandwidth is part of the design, too. Goblin Mosh adds compression and background file transfers with forward error correction—redundant data that helps recover from packet loss. Keyboard input and screen updates take priority over bulk transfers. Its two-pane file browser can move files without making me leave the session.

If I am editing a document over a miserable connection, downloading a PDF should not make the keyboard stop responding. A satellite link makes the trade-off especially obvious, but a busy Wi-Fi connection benefits from the same discipline.

I want remote computing to feel less remote. Sending fewer unnecessary bytes is part of that.

GoblinView: A Desktop Inside the Terminal

GoblinView's executable is goblin-view.

Think of tmux's persistent sessions combined with a DESQview-like desktop: overlapping, framed terminal windows that you can select, move, resize, and raise. There is a keyboard menu. There is mouse interaction. Detaching leaves the programs running, and reattaching brings the desktop back.

The windows are not operating-system windows. They live inside your terminal.

That distinction matters when the desktop is on another machine. I want to arrange my work where the programs are running, leave it there, and return from another connection.

Graphics make this more interesting than drawing borders around shells. Each window has its own terminal and graphics state. A picture belongs to a window: it must move with it, be clipped at its edges, and disappear behind another window when covered. Redrawing some text should not accidentally erase an unrelated equation.

GoblinView has Kitty and Sixel decoding and output paths, including conversion between them. An application can draw using one protocol while the outer terminal uses the other. Keyboard events, clipboard replies, mouse coordinates, and other terminal requests also need to reach the correct window.

This is the practical half of the project in miniature: a multiplexer should not become the point where the terminal's useful features disappear.

It is also the counterfactual half. A terminal-centered world could still have windows, images, and a mouse. It would simply organize those things around terminal applications and persistent sessions.

Goblin Purrfect: Give the Desktop Something to Do

A connection and a window manager are infrastructure. I also want an application that makes the experiment worth using.

Goblin Purrfect is my clean-room, WordPerfect-inspired word processor. The executable is goblin-purrfect.

The point is muscle memory: the function keys, the modal commands, the equation editor, and the feeling of keeping my hands on the keyboard while the document takes shape.

It is not a copy of DOS running in an emulator. The core is Unicode-native. The editor resizes with the terminal. It has mouse selection, clipboard integration, Aspell checking, images, Markdown interchange, and LaTeX/PDF output. The WP character sets belong at the file boundary, not at the center of the program. Text outside their repertoire needs an explicitly defined extension; it is not something old WordPerfect will magically understand.

The equation editor is especially personal. I want to type the compact equation language and see the result immediately. Parsing and drawing the interactive preview happen inside the Rust editor; there is no TeX process started for every keystroke. TeX has a separate job in the PDF printing path.

The preview uses real font outlines and the terminal's measured cell and window dimensions. It scales and centers the equation in the available pane. Kitty is preferred, Sixel is another rendering path, and Unicode Braille dots provide a fallback when neither graphics protocol is available.

If you have a glorious high-resolution display, the equation should use it. The fact that I like an old keyboard interface is not a request for chunky pixels.

The ordinary document page, however, stays terminal text. Font measurements drive wrapping and page estimates, but the editing screen is not an attempt at pixel-perfect WYSIWYG. Equations and images get graphics; paragraphs remain paragraphs. An actual PDF print preview is a separate mode.

That keeps ordinary editing a text-update problem. With Kitty, an unchanged equation can retain its image data while its placement changes. Typing a sentence should not require repainting and shipping an entire raster page.

WP file compatibility is a serious part of the project, but it is still incomplete. Preserving an untouched file is not the same as proving that every edited document will open correctly in original WordPerfect. WP 5.1 and experimental WP 6 output have documented limits. Keep backups; this is development software, not a claim of perfect round-trip compatibility.

The old interface is the starting point. It is not a requirement to preserve the old machine's limitations.

One Experiment, Three Independently Useful Pieces

The intended arrangement is straightforward: open a capable terminal, connect with Goblin Mosh, attach to GoblinView, and work in Goblin Purrfect alongside shells and other terminal programs.

Each piece should also be useful on its own. You do not need my word processor to want a better remote connection. You do not need a remote connection to want persistent, overlapping terminal windows. You do not need either to enjoy a keyboard-driven equation editor.

The seams are where much of the work lives. A feature working directly in Kitty does not prove that it works through a multiplexer, over a lossy connection, after a resize, and again after reattaching from a different terminal. “Modern terminal support” is the direction, not a promise that every protocol combination is already complete.

There are packages, matching source, and setup instructions at the Debian/Ubuntu repository and the Homebrew repository. Check their inventories for the platforms and versions actually available.

Goblin Purrfect and the current GoblinView source use Apache-2.0. Goblin Mosh remains GPL-3.0-or-later as a derivative of Mosh. Bundled fonts, dictionaries, and other third-party materials retain their own licenses and notices.

I am not trying to prove that Windows should never have happened. I am curious about the path we might have taken if terminal applications had remained the center of everyday computing—and whether some of that path is still worth taking now.

A terminal with good typography, useful graphics, persistent windows, and a connection that tolerates bad networks sounds like a perfectly reasonable place to spend the day.

Preferably in amber.