Resurrecting The Muddle (aka MDL) Programming Language

#1

The original source code of the Muddle (aka MDL) interpreter has been found and is running on its original home: The Incompatible Timesharing System (aka ITS) on an emulated PDP-10. This is part of an larger overall project to resurrect ITS.

Muddle itself is a general-purpose language and isn’t directly tied to interactive fiction but it’s probably most well known for its use at Infocom.

–Dave Lebling, Classic Game Postmortem: Infocom’s Zork youtube.com/watch?v=FXdmo2j_CiQ

Announcement at
its.victor.se/pipermail/its-hack … 00236.html

It’s version 56/106 which is newer than the available documentation which covers 55 (ITS version) and 105 (Tenex and Tops-20 versions). Previously, people had thought version 105 was the last mainframe version (before people began porting Muddle to other systems like Apollo Domain workstations, VAX, and UNIX) but it would appear not.

To quote from the announcement:

The people seem to mostly hang out in #pdp-10 in irc.freenode.net but there is, of course, that mailing list.

I can imagine that not everyone will necessarily want to run an ancient operating system on an emulated computer (unless they happen to have a real PDP-10 just laying around somewhere) so there is also an unrelated project to bring Muddle to modern systems, via muddlers.org.

(David Kinder) #2

I am looking forward to playing Zork on ITS, but it’s worth pointing out that an MDL interpreter already exists that can play Zork on modern systems: Confusion, by Matthew Russotto: http://ifarchive.org/indexes/if-archiveXprogrammingXmdlXinterpretersXconfusion.html

#3

It runs a large enough Muddle subset to run a modified version of Zork, and that’s pretty cool, but the goal here isn’t just “to run Zork” but a complete Muddle implementation.

Confusion implements a reduced subset of the language without some of the more demanding features (GOTO, PROCESSes,…), allowing simplifications like using the C stack instead of the MCALL protocol. What it does support is done in a way that chooses straightforwardness of implementation over precisely fitting the nature of the language; in a way it’s an interpreter for a more-easily implemented superset of (the implemented subset of) Muddle, with Muddle’s semantics reproduced with artificial restrictions. E.g. it pays the costs of cons pairs rather than intrinsic linked lists, even though it only allows programs the more limited operations exposed by Muddle’s semantics. It’s a good strategy for the goal of running old Muddle code, but reviving Muddle with all its strengths as a language requires pervasively different design tradeoffs.

#4

I’ve been looking for a PDP 11/85 (micro version) or similar forever. They don’t exist in the resale arena. I think they’ve all been gobbled up by hobbyists or they’re still in use somewhere. Also want a working LA-32 DECwriter. Another unicorn.

#5

I found the following code (which I believe is Muddle code):[code]<SETG ASC-CTJ <ASCII 10>>
<SETG ASC-CTM <ASCII 13>>
<SETG ASC-CTP <ASCII 16>>
<SETG ASC-TAB <ASCII 9>>
<SETG ASC-ESC <ASCII 27>>
<SETG ASC-PRN !(>

<SETG END-READ <STRING <ASCII 27>>>
<GDECL (END-READ) STRING>

<DEFINE CVT (INFILE OUTFILE “AUX” INCH OUCH)
#DECL ((INFILE OUTFILE) STRING (INCH OUCH) )
<COND (<NOT <SET INCH <OPEN “READ” .INFILE>>> .INCH)
(<NOT <SET OUCH <OPEN “PRINT” .OUTFILE>>> .OUCH)
(ELSE
<REPEAT (CHR CHR1 CHR2) #DECL ((CHR CHR1 CHR2) CHARACTER)
<SET CHR <READCHR .INCH '>>
<COND (<==? .CHR ,ASC-CTM>
<SET CHR1 <READCHR .INCH '>>
<COND (<==? .CHR1 ,ASC-CTP>
<SET CHR2 <READCHR .INCH '>>
<PRINC ,ASC-CTM .OUCH>
<PRINC ,ASC-CTJ .OUCH>
<COND (<==? .CHR2 ,ASC-PRN>
<PRINC ,ASC-TAB .OUCH>)
(ELSE <PRINC .CHR2 .OUCH>)>)
(ELSE
<PRINC .CHR .OUCH>
<PRINC .CHR1 .OUCH>)>)
(ELSE <PRINC .CHR .OUCH>)>>
<CLOSE .INCH>
<CLOSE .OUCH>)>>

<DEFINE INIT-CVT (“AUX” INLNT OUTLNT INFILE OUTFILE
(INCHAN .INCHAN) (OUTCHAN .OUTCHAN))
#DECL ((INLNT OUTLNT) FIX (INFILE OUTFILE) STRING
(INCHAN OUTCHAN) CHANNEL)
<REPEAT ()
<READCHR .INCHAN>
<PRINC "Input File: " .OUTCHAN>
<SET INLNT
<READSTRING <SET INFILE <ISTRING 30>> .INCHAN ,END-READ>>
<COND (<0? .INLNT> )
(ELSE <SET INFILE <SUBSTRUC .INFILE 0 .INLNT>>)>
<PRINC ![ .OUTCHAN>
<PRINC .INFILE .OUTCHAN>
<PRINC !] .OUTCHAN>
<CRLF .OUTCHAN>
<PRINC "Output File: " .OUTCHAN>
<SET OUTLNT
<READSTRING <SET OUTFILE <ISTRING 30>> .INCHAN ,END-READ>>
<COND (<0? .OUTLNT> <SET OUTFILE .INFILE>)
(ELSE <SET OUTFILE <SUBSTRUC .OUTFILE 0 .OUTLNT>>)>
<PRINC ![ .OUTCHAN>
<PRINC .OUTFILE .OUTCHAN>
<PRINC !] .OUTCHAN>
<CRLF .OUTCHAN>
<CVT .INFILE .OUTFILE>>>

<OR <LOOKUP “COMPILE” > >[/code]

#6

I realise this is an old thread now but just to pick up on the usage of MDL, there are a small group of users (me included) who use ZIL which is the trimmed down version of MDL made specifically for creating interactive fiction games.

(Jesse McGrew) #7

muddlers.org seems to be defunct. What happened with that?