The Next Generation Server for Virtual World Builders

Muq, the next-generation mudserver, is now publicly available in pre-beta form, together with a minimal basic MUD package for experimentation purposes (nicknamed CrashMuq).

The first full beta release of Muq, originally set for 15 March 1997, has been postponed while Cynbe and Sandy settle in to their new digs and get the machines set up again. Pushing the date back was necessary because of the unusual nature of the Muq code, in that once a distributed system is started up it is extremely hard to shut it down again for updating (as the designers of the IP system have discovered). "We will ship no line before its time..." ;^)

At this stage, the description that follows is largely meant for a technically savvy audience, because Muq is a foundation and toolkit upon which more generally accessible worlds may be built.

If you're already familiar with Muq: Shortcut to Download Site Shortcut to Mirror Site

Otherwise, read on...

If you are a virtual world builder and are sick of trying to do real work with toy tools, Muq may be what you've been looking for.

Muq is animated (among other things) by a desire to construct secure, cooperative, democratic, egalitarian, distributed online communities based on free software and user-owned hardware instead of on proprietary commercial hardware and software.

Muq is not just another chip off the old block, but a total re-analysis, re-design and re-implementation of the mudserver concept by someone who has been mudding for years and implementing compilers, interpreters and software environments for decades.

Feature summary

True bytecoded compiler/interpreter,
carefully optimized for speed.
True software virtual memory.
True compacting ram manager.
True incremental garbage collection.
True policy-free virtual machine.
True symbolic pathnames.
True user shells.
True pre-emptive multitasking.
True contemporary first-class datastructures, including floats.
True contemporary programming languages.
True delegation-based object-oriented programming.
True multi-user protection.
True incremental backup.
True eight-bit strings, streams and network sockets.
True factored support libraries.
True portability.
True reliability.
True security throughout.
Heavily commented source throughout.

If you're ready for the next generation, it's ready for you.

Feature descriptions

True bytecoded compiler/interpreter,
carefully optimized for speed

Muq compiles code into true byte-coded executables, executed by a tuned interpreter with peak instruction issue rates several times that of the closest competitor. This means you can afford to code in-db things which you would have to code in-server on other servers. Furthermore, Muq executables demand-page in virtual memory just like everything else: You can afford to have lots of code in-db without bloating your process or slowing server startup.

True software virtual memory

Muq only loads into memory what you are actually using. This means that your process size can be a tenth of your db size, opening doors other servers slam shut. Muq's virtual memory support was designed in from day one, not awkwardly retrofitted, and uses a carefully tuned custom virtual memory module, not a generic database package, yielding unexcelled disk and ram performance.

True compacting ram manager

No more endlessly bloating processes or memory leaks! Other servers abuse malloc() shamelessly rather than implement a true ram management system like those used by production-quality Lisp and Smalltalk systems (or even Basics, for that matter). Muq periodically compacts memory to free up wasted ram, potentially saving hundreds or even thousands of dollars worth of ram.

True incremental garbage collection

Modern programming environments like Smalltalk and Lisp automatically recover lost objects, so you don't have to waste time and effort worrying about memory leaks. Muq does too, using an incremental algorithm so the server never stops long enough for you to notice.

True policy-free virtual machine

Tired of fighting your server? The C-coded Muq server implements just the functionality you need, while leaving policy issues to in-db code: You can reconfigure Muq to be virtually anything you want, without touching a line of C code.

True symbolic pathnames

You will never type "#61422" in Muq. You will never be embarassed explaining to a new user that objects are named by numbers, and one has to get used to writing them down. You will never face the portability headaches posed by hardwired numeric dbrefs. You will never feel as though you had been transported back to the software environments of the early 1950s, before the idea of symbolic names was introduced.

Muq uses a variant of the familiar /usr/local/lib path notation used by unix and World Wide Web URLs, integrated with the package:symbol notation from Common Lisp -- two winning notations backed by untold hacker-millenia of testing and incremental refinement. Paths may be expressed relative to the current job, current user, current object, current root, or any current variable, and may chain through any property on any object (subject to privilege checking).

True user shells

Many servers hardwire the user interface into the server. Unix makes the user shell a separate unprivileged process, allowing users to individually select whatever interface style they wish.

Muq does too: The user shells are coded entirely in-db and require no special privileges. The standard Muq distribution provides a selection of shells, and in addition a number of third-party user shells have already been written, and it seems safe to say that more are on the way.

True pre-emptive multitasking

Tired of servers that seem perpetually lagged? Muq is carefully designed throughout to have a crisp, responsive feel, and as part of that design Muq implements a pre-emptive multi-tasking system similar to that universally used by production timesharing operating systems. This means that simple user requests can get quick responses while more demanding user computations continue in the background.

Muq jobs also communicate via streams which operate much like unix pipes extended to allow transmission of arbitrary values (instead of just a bytestream), allowing unix-style pipelines of jobs and trivial construction of in-db robots. Unleash your imagination! :)

True contemporary first-class datastructures, including floats

Tired of servers that seem to think that all the world's a string? Muq provides a full range of modern datatypes and datastructures, including strings, integers, floats, arrays, Lisp-style lists, packages, symbols, stacks, streams, and objects with property directories.

All value slots in Muq are first class: Any value can be stored anywhere any other value can.

True contemporary programming languages

Tired of trying to write real programs in toy languages? Tired of servers that offer you any language syntax you want, as long as it is X?

Muq bytecode compilers are implemented in-db using an assembler class that handles most of the busywork and guarantees production of only valid executables, allowing new compilers to be written by unprivileged users.

Muq already supports a variety of popular programming syntaxes including a large and growing subset of Common Lisp which should eventually be a complete, compatible implementation, allowing you to port code back and forth and to take advantage of existing code libraries. If your syntactic religion isn't supported yet, it is not hard to add a compile for it as well, probably starting with one of the existing ones.

At the semantic level, the Muq virtual machine provides just about everything you've heard of, and some things you may not have, including vanilla functions, generic functions, anonymous functions, promises with implicit forcing (in Scheme nomenclature -- a substrate suitable for experimenting with functional programming), thunks (something vaguely like named pipes in unix), semaphores for mutual exclusion, implicit job blocking on bounded streams, and sophisticated exception handling facilities.

True delegation-based object-oriented programming

Experience has shown that classical object-oriented programming is a clumsy tool for rapid, experimental such as one tends to find in the mud environment.

As a result, attention has been focussing recently on delegation-based system which dispense with indirection through classes, and instead attach methods directly to objects and allow objects to inherit directly from each other.

Muq implements a delegation-based object system with multiple inheritance and message passing via generic functions, so simply that a new message may be interactively defined, implemented, and attached to an object in half a line of code.

True multi-user protection

If you are like me, you want to empower the users of your virtual world while providing them a stable, reliable environment with real privacy where it counts -- and you resent servers so insecure that you are forced to choose between refusing programming privileges to most users, or else dispensing with any real expectation of reliability, security or privacy.

Muq lets you have it both ways, by implementing serious multi-user protection inserver: In a bare system, users can modify only datastructures which they own, and access only datastructures deliberately published by other users. You provide additional means of interaction by providing system utilities, either from the standard distribution, third party libraries, or custom code you've written yourself.

True incremental backup

Tired of seeing interactions between dozens of users come to a screeching halt while the server checkpoints the db? Muq does backups incrementally while user code continues to run -- one more way of improving interactive response.

True eight-bit strings, streams and network sockets

Interested in multimedia applications or binary communication with other servers? Muq strings may contain arbitrary eight-bit data, and Muq network sockets may be configured to pass eight-bit binary data by a simple parameter setting. (By default, Muq sockets filter out various control characters, for security security-conscious users who prefer that.)

True factored support libraries

Tired of "minimal db"s full of stuff you don't want? Tired of core facilities which are impossibly difficult to update in an established db? Tired of portability problems tranferring code between even matching servers?

The Muq "minimal db" isn't even an empty file: The server can create and initialize a blank db starting from nothing.

System libraries are distributed as unix source files, and may be installed not at all, one at a time by hand, or en masse via one of the distributed scripts, according to your preference. Install as much or as little as you please.

Inside the db, code is segregated into Common Lisp style packages, making is a snap to remove an unwanted package if you change your mind.

When system library updates come out, installing any library updates you wish is just as simple as the original installation.

You'll think you're living in the '90s!

True portability

Tired of tweaking config.h to get the server to compile? Muq autoconfigures and compiles on most major Unix variants (including Irix, OSF/1, Linux, Ultrix, SunOS, NeXTStep and AIX) with a simple "make". Support for other unix variants is being added as quickly as we can get access to them.

True reliability

Tired of daily bug reports? Tired of discovering the hard way that it didn't install right? Tired of servers that leave reliability to chance? That look like throwaway toys written by undergrads?

Muq was developed from day one with the design goal of production-quality reliability, and the willingness to invest the work needed to make it happen.

The exhaustive regression test suite has been developed hand-in-hand with the server implementation, and each software layer in Muq has been thoroughly tested before starting implementation of the next layer. There are thousands of lines of code inside and outside the server devoted exclusively to selfcheck.

The regression suite has been used constantly throughout development to catch bugs promptly and efficiently, and comes with the Muq package for use in verifying that Muq is functioning correctly on your system. If the complete Muq selftest runs without reporting any problems, you have reasonable assurance that you have a good install.

Finally, the policy-free server design means that you can implement almost all needed local customizations entirely in-db, vastly reducing the incidence of locally generated crashing bugs.

True security

You can run a Muq without having your users run amok:

Consistent attention to intra-db security issues throughout the architecture: In general, users can only modify objects they own and read values designated as public. You can let your users write real code without paying a real security/privacy cost. You can extend additional privileges as needed by supplying setuid-root functions, which can be written to work for one, some or all users.

Separate 8K bitmaps allow port-by-port control of outbound network connections for Muq users and Muq admins: You can let your users access the Web without having them access your passwords via your subnet X servers or NFS servers. If you prefer, clear the bitmaps to zero to completely disable outbound network connections.

Carefully limited access to the host system from Muq, to ensure that even if internal Muq security is compromised, (perhaps via a badly written local setuid-root function) the host account and system remain secure.

Heavily commented source throughout

Tired of implementors who seem to feel that it is better that a thousand reader hours be spent guessing what was on their mind than that they waste a single minute commenting?

Muq source, in-server and in-db, is written to be read, not just to be compiled. Even if you don't enjoy the jokes, quotations and epigrams, you'll appreciate the code clarity when the day comes to modify or extend part of it.

The Muq Project

If you like the vision of online communities not controlled by the likes of Microsoft or America Online, you can contribute to making it happen. You don't need to be a hacker to contribute: If you want to contribute, we guarantee you have something we need, be it the ability to provide novice-eye feedback on our manuals and tutorials, art of any kind for our manuals, web pages and virtual worlds, technical writing or proofreading for our documentation, coordination of volunteer efforts, donation of hardware access to run testbeds, or whatever -- join one of the Protomuq mailing lists or email Cynbe and see where you can fit in.

This is a preliminary announcement. An updated version will be published as part of the documentation package accompanying the full Beta release. Comments are welcome.
This page is maintained by Allucquere Rosanne Stone.
Muq is written by Cynbe ru Taren.

For more information, documentation, and pre-beta source code:
Go to the Muq Project Homepage
Go to the Protomuq Project
Back to Sandy Stone's Homepage
This page last updated 4 January 1997
from the ACTLab, Austin.