TinyFugue

TinyFugue (universally abbreviated tf) is a flexible, screen-oriented MUD client for Unix-like systems, distinguished by the powerful scripting language embedded within it. Designed for playing text-based online worlds — MUDs, MOOs, MUCKs, and TinyMUD derivatives — TinyFugue lets players automate their gameplay through macros, triggers, hooks, and variables, all expressed in a compact domain-specific language that runs inside the client. For much of the 1990s and 2000s it was among the most capable and widely used clients in the text-gaming community, and it remains maintained today through a community revival.

History & Origins

TinyFugue was not the first MUD client, but it grew directly out of the ones that were. The lineage begins in January 1990 with TinyTalk, written by Anton Rang for Unix-like systems — one of the first clients to offer a meaningful set of automation features. In May 1990, Leo Plotkin released TinyWar, built on TinyTalk, which notably introduced event-driven programming to the client — the idea that incoming text could automatically fire scripted responses.

In September 1990, Greg Hudson released TinyFugue, based on TinyWar and TinyTalk, and pushed the concept further with more advanced trigger support. The name plays on the era’s fashion for “Tiny”-prefixed software built around TinyMUD, combined with “Fugue” — the interwoven musical form — evoking the layering of automated responses.

In July 1991, development passed to Ken Keys (known online as Hawkeye), who took over the design and maintenance of TinyFugue and shepherded it for well over a decade. Under Keys, TinyFugue matured into a robust, feature-rich client whose scripting language became one of the most expressive in the MUD world.

The Rebirth

After the release of 5.0 beta 8 on January 14, 2007, active development from Ken Keys wound down. The client remained widely used and packaged in Linux distributions, but the codebase went quiet for years. In the mid-2010s, a community developer working under the GitHub handle ingwarsw launched a “Rebirth” fork, gathering the patches that had accumulated across the community and publishing them under continued semantic-versioned releases. This revived line has added modern conveniences — including Python and Lua scripting integration, wide-character support, and newer telnet negotiation options such as ATCP and GMCP — reaching version 5.2.2 on October 28, 2024.

Design Philosophy

TinyFugue’s scripting language exists to solve a specific problem: text worlds send a continuous stream of output, and players want to react to it instantly and consistently. Its design reflects that goal.

• Event-driven at the core — The central construct is the trigger: a pattern that watches incoming text and fires commands when it matches. Hooks extend the same idea to internal client events (connecting, disconnecting, receiving activity in another world).
• Screen-oriented — Unlike line-at-a-time clients, TinyFugue maintains a full-screen terminal interface with separate input and output regions, a scrollback history, and status lines, giving players a stable workspace.
• Everything is a macro — Aliases, triggers, hooks, and keybindings are all unified under the concept of the macro, a named body of commands with optional triggering conditions.
• Text-centric and untyped — Values are strings; the language leans on Perl-compatible regular expressions and substitution rather than a rich type system.
• Multi-world by design — The client is built to hold several server connections at once, so scripts can route, monitor, and switch between worlds.

Key Features

TinyFugue’s scripting environment provides a comprehensive toolkit for automating and shaping MUD sessions.

Macros and Triggers

1
2

/def greet = say Hello, everyone!
/def -t'{*} tells you {*}' auto_reply = tell %1 Got it: %-2

/def defines a macro; the -t (trigger) flag attaches a text pattern so the macro fires automatically when matching output arrives.

Variables and Substitution

1
2

/set target=dragon
/echo My target is %{target}

Variables store state, and %-style substitution expands them inside commands, enabling dynamic, reusable scripts.

Hooks and Highlighting

1
2

/def -h'CONNECT' on_connect = /echo Connected to a new world
/def -F -t'{*} has arrived' -h -P0Bgreen highlight_arrival

Hooks respond to internal client events rather than server text, while highlight definitions colorize matching lines — one of the features that made the interface far more readable than a raw telnet session.

Control Flow and Expressions

1
2

/if ({hp} < 100) /quaff healing %; /endif
/test result := 5 * (3 + 2)

Conditionals, loops, and an expression language with arithmetic and string functions give TinyFugue genuine programmatic power well beyond simple aliasing.

Networking and Protocols

Over its life the client accumulated support for TCP over IPv4 and IPv6, SSL/TLS, several TELNET option variants, MCCP compression, and ANSI color codes — turning a simple terminal tool into a capable, modern network client.

Evolution

TinyFugue’s history divides into clear eras of stewardship:

The 4.0 release became the long-lived stable branch, while the 5.0 beta line (culminating in beta 8 in 2007) introduced Perl-compatible regular expressions, SSL, and IPv6. The community Rebirth fork later carried the codebase forward under fresh version numbers.

Current Relevance

Text worlds are a niche today compared with their early-1990s peak, but TinyFugue endures. It is packaged for Debian and Ubuntu (as tf5), builds on essentially any Unix-like system, and — according to its documentation — has historically run on macOS, Windows via Cygwin, OS/2, and BeOS. The Rebirth fork keeps the project alive on GitHub with ongoing releases and modern scripting integrations.

For the communities that still play MOOs, MUCKs, and MUDs, TinyFugue remains a benchmark client: fast, keyboard-driven, deeply scriptable, and comfortable inside a terminal or an SSH session.

Why It Matters

TinyFugue is one of the longest-lived scripting environments to emerge from the text-gaming world. For a generation of players, writing a TinyFugue trigger to auto-heal, a hook to flag activity in another world, or a macro to speedwalk across a map was an accessible first encounter with event-driven programming — pattern-matching against a live data stream and reacting automatically. Its journey from a 1990 client layered atop TinyTalk and TinyWar to a still-maintained tool more than three decades later is a testament to the durability of small, focused, open-source software and to the inventive, self-taught programming culture that grew up inside virtual worlds made entirely of text.

Sources

• TinyFugue (official site)
• ingwarsw/tinyfugue — “Rebirth” fork on GitHub
• List of MUD clients — Wikipedia
• tf(1): TinyFugue man page