Multiuser
Online
Objects &
Relations
"Moor" is:
Moor provides (from the bottom layer up...)
And it is designed to be used for:
Socializing, authoring, and creating on the Internet is in many ways broken. We want to make it better, by giving people tools to create their own spaces, and to create their own things and tools within those spaces.
It should be fun, it should be easy, it should be accessible, it should be open, it should be collaborative, it should be programmable, it should be extensible, it should be secure, it should be private, it should be free.
This kind of environment is our take on how we can make that happen:
In short: Build your own village.
Launching in the early 1990s LambdaMOO is an online social environment, as well as an open source software package for building such environments for yourself.
LambdaMOO -- the place -- still exists today, with an unbroken 30+ year history, and a small but dedicated community of users and developers continue to use it -- both LambdaMOO the place, and MOO the server software for other communities.
MOO predates "social media", predates Facebook, Twitter, MySpace, Friendster, Tumblr, GeoCities, and... everything else.
In fact, it predates the world-wide web itself, and offers a very different kind of interaction with the Internet, one that is synchronous and live, text-based, not graphical, and is based around an evolving narrative that the users themselves create.
It is a multiuser virtual world, a MUD, a narrative "game", a chat room, a virtual environment, a social network, a programming environment, and a platform for collaborative fiction -- all in one.
It is a place where people can meet, talk, and build things together. And it's kind of awesome.
(for a longer description, see doc/lambda-background.md)
But it some senses, the actual technology did not age well at all. It lacks multimedia of any kind, its interface is dated, it is not very accessible to new users, and the once active community of developers and participants has dwindled to a small but dedicated group of enthusiasts.
And the server itself is aged; it is written in C -- is single threaded, with some known architectural limitations, and is not very easy to extend or modify. While there are newer versions and forks (such as Stunt, ToastStunt, etc.) that address many of these issues, they are still based on the same original codebase and architecture -- remaining bound by the single-threaded, single-core model of the original.
Moor is an attempt to reimagine LambdaMOO for the modern world, while retaining the core concepts and ideas that made it so compelling in the first place. It is a ground-up rewrite (in Rust). And while it maintains full compatibility with existing LambdaMOO "cores" (databases, worlds), it also offers a new, more flexible and extensible architecture, and extensions to the runtime to make it more adaptable to modern use cases:
The primary audience at this time is developers and administrators of existing MOO environments, and people who are interested in building new MOO environments, or people who are interested in extending this system out along the vision described below (under "What's next?").
If you're an existing MOO administrator, you can run your existing MOO database on Moor, and it should work just fine, with the following caveats:
map
type, WAIFs etc.). (Some of these may
come in the future. Or not.)The easiest way to get started is to run the docker compose
setup. This will bring up a complete server with telnet
and websocket
interfaces. The server will be setup with an initial JaysHouseCore
core import.
To run, take a look at the local docker-compose.yml
file, instructions are there, but it really just amounts to:
docker compose up
This setup is intended for development and testing. In particular, all binaries are compiled in (slower, fatter) debug mode, and any changes to the source code will cause a rebuild of the server, and a restart of the server. This is useful for development, but not for production.
However, the docker-compose.yml
file is a good starting point for understanding how to run the server in a production
environment. The server is composed of a number of services, including the moor-daemon
binary, and various
"host" services which provide the actual interfaces to the server.
The server is written in Rust, and is composed of a number of crates and running services. These services communicate with the main server process over an RPC system and message bus implemented on top of ZeroMQ.
For a high level architecture description plus a more detailed breakdown on how the server is put together, see the ARCHITECTURE.md document.
Moor is licensed under the GNU General Public License, version 3.0. See the LICENSE file for details.
You can make modifications as you like, but if you distribute those modifications, you must also distribute the source code for those modifications under the same license.
The choice to use the GPL was made to ensure that the software remains open and free, and that any modifications to it are also open and free. This is in keeping with the spirit of the original LambdaMOO server, which was also under the GPL license.
Further, since portions of the code inside moor
are based on readings of the LambdaMOO server code, staying with
the GPL is the right thing to do.
The bulk of development has been by myself.
Extensive work on the decompiler/unparser, along with general testing, code sanitization, and cleanup has been done by Norman Nunley.
Implementation of a robust integration testing framework, along with porting a pile of tests from ToastStunt, and generally finding bugs and helping with the fixing of them has been done by Zoltán Nagy.
There's been plenty of inspiration and help from a community of fellow old-school MOO (and ColdMUD!) folks that I've known since the 90s.
Finally, LambdaMOO itself was primarily authored by Pavel Curtis, with the original LambdaMOO server being written by Stephen White. Successive versions and forks have been maintained by a number of people.
At this point Moor
is capable of executing most of the LambdaMOO 1.8.x system, and is capable of running existing
LambdaMOO databases. This includes support for the full language, the bulk of builtin functions (enough to run the cores
I've tried),
the scheduler including forked and suspended tasks (including persisting them between restarts), importing and exporting
existing LambdaMOO compatible textdumps, the read()
builtin and user input, and a network layer that supports both
telnet and websockets,
and can be extended to support other protocols.
With some caveats:
For a list of the status of the implementation of standard LambdaMOO builtin functions, see builtin_functions_status.md.
There's a lot of work to do. We're looking for contributors, testers, and users. We're also looking for feedback, ideas, and use cases.
We're also looking for funding, and for partners who want to build things on top of Moor.
The immediate horizon is to get the initial release out, which will be a drop-in replacement for LambdaMOO, with some additional features. This will include a web-based client. To get there the following is still required
The intent is to get to a 1.0 release after these are done. This 1.0 release will be fully compatible with existing LambdaMOO databases, and will be a drop-in replacement for LambdaMOO.
The roadmap for future features after the initial 1.0 release include:
web
host repository, but
it's still very early. The intent is to provide a more modern, graphical, and interactive experience, while
still retaining the narrative and creative aspects of a MOO. It will additionally provide modern authoring
tools like a syntax highlighting, auto-indenting editor, a Smalltalk-style object browser, and a debugger.
Some prototype work on this has already been done:
#123
style) will be replaced or
subsumed by object-capability references. The challenge being to maintain backwards compatibility with existing
cores.If you're interested in helping out, or just want to chat, please join us on our Discord server.
Note: When the time is right the Discord will be replaced by a running instance of moor
itself.