I've had a facination with MOOs since before I knew there was such a thing.
Back in the 80's, writing very limited and dull adventure games in BASIC on
my Atari, I felt there was something interesting here, but I could never
make the the hard-wired spaghetti code into anything worthwhile.

Sometime in the early 90's, the BBS days, I experienced multiuser systems
for the first time, and even played a few multi-user "door games". Not much
later, I read in Wired about the online world of the MUD. What I took away
from that article was the idea of a world that could be created on the fly,
inside itself. I was blown away. I made some abortive attempts at making a
single user MUD, in non-spaghetti-code QuickBasic on my Dad's 286, but it
never got off the ground.

Not much later, I was in college, exploring the internet, and multi-user
systems. I logged into a few MUDs, and MUSHes, and found out that I wasn't
very interested in exploring them, or role-playing in them, but was instead
mostly interested in finding out how they worked, and building stuff inside
them. Over a couple of years, I dabbled in this from time to time, ran a
few small MUDs and MOOs of my own, so I could play with programming inside
them, and gradually began finding fault with many aspects of what was then
the state-of-the-art MOO. My biggest gripe was the lack of a decent
language to program in inside the MOO.

In '98, I began writing perlmoo in an attempt to address that. Perlmoo was
extensible from inside the MOO, in perl. It ran as a single perl process,
and had limited and highly theoretical security, a design that copied
LambdaMoo wherever possible, and no multitasking at all. (I was waiting on
production quality perl threads. I still am. :-P) Perlmoo was developed
through late '99 (though the last 6 months were an abortive rewrite), and
at its peak was a fully usable MOO, despite its architectural problems.

Then circumstances caused me too be to busy coding to work on MOOs for a
while, but I did spend some time learning about interesting MOO
architectures, and mulling over what was right and wrong with perlmoo. I
did some crazy, and seemingly unrelated, things like implementing
object-oriented programming in POSIX shell script. I also got interested in
limited-domain natural language processing, and wanted to have a try at
applying it to a MOO.

Then in 2001, I had the key idea: Instead of running the MOO off in a
corner of a unix system, as essentially a single process, and implementing
something not unlike a whole unix system inside the MOO, just turn the MOO
into the unix system. Use every unix strength possible to the advantage of
the MOO; its multiuser nature, preemtive multitasking, disk caching, device
abstraction, numerous programming languages, editors, libraries, etc. Paper
over the flaws and the parts that just don't map into a MOO, taking
advantage of unix's extreme flexability and malleability to do so. 

I stirred a few other things into the pot, like NLP, and what I hope will
be a very secure -- but not limiting -- permissions system. The result is
mooix. I hope you like it.

-- Joey Hess <joey@mooix.net>
