moor

Interesting, as a LambdaMOO user -- which borrowed many of the forms of TinyMUD but in its own lineage -- I wasn't aware of this earlier form of "page"; On LambdaMOO (and LambdaCore) whisper was for in-room communication and "page" sent a message to someone privately anywhere on the MOO. In reality nobody used whisper. I never knew there was a form of page that didn't carry a message. Things like your "mutter" were easy to code up in MOO, and I recall people doing things like this, but it being seriously seriously frowned upon. BTW you might be interested in my project https://github.com/timbran-project/moor

Like LambdaMOO (or my variant of it https://github.com/timbran-project/moor) or my language https://github.com/timbran-project/mica

I thought it would be fun to do a modern reimplementation of LambdaMoo, but someone already did it in Rust! https://github.com/timbran-project/moor

You would probably like my project https://github.com/timbran-project/moor

I find for these kinds of systems, if I pre-seed Claude Code with a read of the language manual (even the BNF etc) and a TLDR of what it is, results are far better. Just part of the initial prompt: read this summary page, read this grammar, and look at this example code. I have had it writing LambdaMOO code, with my own custom extensions (https://github.com/rdaum/moor) and it's ... not bad considering.

I mean let's be fair: back then MUD nerds were using LambdaMOO's "moo" language and LPmud's "LPC" before things like Python were mainstream or serious, Perl pre-5.0 was terrifying and limited, and Ruby wasn't even on the radar. So when we went to go do "serious" work we kinda missed them. Your options in 1991, 92, 93 were earlier perls, shell + awk/sed, or maybe tcl or a lisp/scheme if you were lucky. The languages inside those MUDs actually were ahead of their time, and their programming model -- in the case of MOO [and its offshoots CoolMUD and ColdMUD] at least -- was more similar to advanced systems like Smalltalk or Self which were hot interesting topics at the time. Being "confined" to being "game" languages made them not get taken seriously (unlike "JavaScript" which arrived with all sorts of weird warts but had Netscape's brand on

lambdamoo rewrite https://github.com/rdaum/moor/

LambdaMOO was(is) like this. And even more literally than in Smalltalk. Persistent objects, object oriented programming language, live code editing, object manipulation, programming right in the world, with immediate and shared effect. But unlike a Smalltalk environment, the things you were editing were (in metaphor at least) living narrative "world" objects like rooms, objects, characters, etc. meant to give a (text-based) "VR" aspect. And it was multiuser, so collaborative. It's a compelling, though exotic, way of making things. I'm attempting to defibrilate the whole thing here: https://github.com/rdaum/moor

I write my own software compulsively every weekend and holiday, often at the expense of housework and personal relationships. It just has no path towards paying the bills or putting my teens through university. http://github.com/rdaum/moor

Don't threaten me with a good time! And I still to this day enjoy combining your #3 (emacs) with your #5 (MOO) via e.g. https://github.com/toddsundsted/rmoo You might appreciate my project: https://github.com/rdaum/moor (Though it's in a bit of a slow period because of Real Life(tm))

I think Haskell or OCaml would do a better job on the ADTs for a parse tree. When doing this, I found Rust's enums... anemic... and got very annoyed by the awkwardness of having to Box recursive types. I was reaching for the ability to continue to be able to pattern match on nodes while attaching common attributes (line numbers, etc.) and ended up having to bury everything 1 level deep in a struct which ended up feeling awkward. That and Rust's iterators are terrible at introducing ownership agony. In any case, I've ... done it (https://github.com/rdaum/moor/blob/main/crates/compiler/src/...) but can't say I liked it. I do really like "pest" as a parser generator though. In general, yes, the Rust ecosystem is bigger/richer, and growing.

I got my start on the Internet in the very early 90s playing with, authoring in, and programming on LambdaMOO (https://en.wikipedia.org/wiki/LambdaMOO) and similar systems. Shared virtual social spaces, with a persistent object oriented authoring / scripting language. They can be classified as MUDs (depending on who you talk to) but the focus is social, creative / authoring, and shared programming not RPG gaming. I've always wanted to see this kind of thing modernized and further developed. Over the last 25 years or so I've worked on similar but novel & improved things, but never finished. So I decided to just re-implement LambdaMOO and use that as a base, instead and keep compatibility as a goal, but build it out on a more modern foundation that takes advantage of multiple core machines, newer network protocols, newer connectivity method

https://github.com/rdaum/moor (see the thread elsewhere in the comments) command parser & matcher stuff is partially here: https://github.com/rdaum/moor/blob/main/moor-lib/src/tasks/c... and https://github.com/rdaum/moor/blob/main/moor-lib/src/db/matc... https://github.com/rdaum/moor/blob/main/moor-lib/src/db/matc...

I would much much rather see a reboot of the MOO concepts (persistent object-oriented world, global time). I know the existing LambdaMOO core and server are still being maintained, and web-ified, but even though I am something of a dissenter from the whole Rust trend, I'm very interested in this, which is going about it IMO the right way: https://github.com/rdaum/moor MOO was a good time.

I've been working on a rewrite of the server into Rust, for kicks: https://github.com/rdaum/moor Unfortunately still lots of work there to be done, and I have no time. (But it does load and compile an entire core to opcodes, accept connections, and do its best effort at scheduling and executing verbs. Just doesn't get far enough to present anything like a running MOO yet)