From: jds@math.okstate.edu (Jennifer "Moira" Smith)
Subject: [rec.games.mud]: FAQ #2/3: MUD Clients and Servers
Followup-To: rec.games.mud.misc
Summary: mud clients and servers, descriptions and locations of source
Keywords: muds clients servers tinytalk ftp
Supersedes: <faq_clients_717919204@math.okstate.edu>
Reply-To: jds@math.okstate.edu
Organization: Oklahoma State University, Math Department
Date: Fri, 16 Oct 1992 06:00:16 GMT
Expires: Sat, 14 Nov 1992 06:00:03 GMT

Archive-name: mud-faq/part2
Version: $Id: faq.clients,v 2.16 92/09/15 18:53:05 jds Exp $

FREQUENTLY ASKED QUESTIONS:  MUD Clients and Servers

This is part 2 in a 3 part series of FAQs.

Disclaimer: The authors and sources of this document are generally
            biased towards TinyMUDs and their ilk, since we play
            them more. An attempt is being made to fairly cover
            every mud available.

"What are clients?"

  Clients are programs, usually written in C, that connect up to
  servers.  Telnet is one such client program.  Many clients written
  for MUDs have special added bonus features through which they filter
  the output; most, for instance, separate your input line from the
  output lines and wraps words after 80 columns.  Some also have a macro-
  writing capability which allows the user to execute several commands with
  just a few keypresses.  Some allow you to highlight output coming from
  certain players or suppress it altogether.  Still other clients make
  the sometimes tedious task of building new areas a breeze.

"Where do I get clients?"

  Listed below is a list of clients, and a site or two where they can
  be ftped from. If the site is down, your best bet is to ask around.
  In general, ferkel.ucsb.edu (128.111.72.60) and ftp.math.okstate.edu
  (139.78.10.6) are good places to look.
 
"Do I need a special operating system to run clients?"
 
  Yep, you sure do.  Most use BSD Unix, although there are clients which
  also run under SysV Unix with networking, VMS with either MultiNet or
  Wollongong networking, and there's even one for IBM VM, and a new
  one that runs on a Macintosh.

"What clients are out there, and how are they different?"

  Here's a reasonable accurate listing of available clients. Please note
  that we have not tested each of these, and they're not guaranteed to
  work for you. 

  UNIX clients appear first, VMS clients next, miscellaneous clients last.
  EMACS clients for UNIX appear after those written in C.

  Name            Description
  ----            -----------

  TinyTalk        Runs on BSD or SysV with networking. Latest version is 
                  1.1.7GEW. Designed primarily for TinyMUD-style muds. 
                  Features include line editing, command history,
                  hiliting (whispers, pages, and users), gag, auto-login,
                  simple macros, logging, and cyberportals.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
                  parcftp.xerox.com(13.1.64.94):/pub/MOO/clients
		  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients

  TinyFugue       Runs on BSD or SysV with networking. Latest version is 
                  2.0beta6. Commonly known as 'tf'. Designed primarily for
                  TinyMUD-style muds, although will run on LPMUDs and Dikus.
                  Features include regexp hilites and gags, auto-login, macros,
                  line editing, screen mode, triggers, cyberportals, logging,
                  file and command uploading, shells, and multiple connects.
                  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients

  TclTT           Runs on BSD. Latest version is 0.9. Designed primarily for
                  TinyMUD-style muds. Features include regexp hilites, regexp
                  gags, logging, auto-login, partial file uploading, triggers,
                  and is programmable.
                  ftp.white.toronto.edu(128.100.2.160):/pub/muds/tcltt

  VT              Runs on BSD. Latest version is 2.12. Must have vt102 
                  capabilities. Useable for all types of muds. Features
                  include a C-like extension language (VTC) and a simple
                  windowing system. Typical client features can be
                  programmed. Does come with a VTC distribution file for 
                  mud client support.
                  ftp.math.okstate.edu(139.78.1.12):/pub/muds/clients
                  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients

  LPTalk          Runs on BSD or SysV with networking. Latest version is 1.2.1.
                  Designed primarily for LPMUDs. Features include hiliting, 
                  gags, auto-login, simple macros, logging.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients

  SayWat          Runs on BSD. Latest version is 0.2.18. Designed primarily for
                  TinyMUD-style muds. Features include regexp hilites, 
                  regexp gags, macros, triggers, logging, cyberportals,
                  rudimentary xterm support, and file uploading.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients

  PMF             Runs on BSD. Latest version is 1.12.1. Usable for both LPMUDs
                  and TinyMUD-style muds. Features include line editing,
                  auto-login, macros, triggers, gags, logging, file uploads,
                  an X-window interface, and ability to do Sparc sounds.
                  ftp.lysator.liu.se(130.236.254.1):/pub/lpmud/clients
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients

  TinyView        Runs on BSD. Latest version is 1.0. Designed for use primarily
                  for TinyMUD-style muds. Features include screen mode, macros,
                  history buffers, line editing, and multiple connects.
                  altair.csustan.edu(130.17.1.50):/pub/mud/mud_misc

  TINTIN          Runs on BSD. Latest version is 2.0. Designed primarily
                  for Dikus. Features include aliases(?), triggers,
                  tick-counter features, and multiple connects.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
                  ucbvax.berkeley.edu(128.32.133.1):/pub/games/dikumud/utility

  MUD.el          Runs on GNU Emacs. Usable for TinyMUD-style muds, LPMUDs,
                  and MOOs. Features include auto-login, macros, logging,
                  cyberportals, screen mode, and it is programmable.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
  
  TinyTalk.el     Runs on GNU Emacs. Latest version is 0.5. Designed primarily
                  for TinyMUD-style muds. Features include auto-login, macros,
                  logging, screen mode, and it is programmable.
                  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients

  LPmud.el        Runs on GNU Emacs. Designed primarily for LPMUDs. Features
                  include macros, triggers, file uploading, logging, screen
                  mode, and it is programmable.
                  ftp.lysator.liu.se(130.236.254.1):/pub/lpmud/clients
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients

  CLPmud.el       Runs on GNU Emacs. Designed primarily for LPMUDs. Similar
                  to LPmud.el, but with the added capability for remote
                  file retrieval, editing in emacs, and saving, for LPMud
                  wizards.
                  mizar.docs.uu.se(130.238.4.1):/pub/lpmud

  MyMud.el        Runs on GNU Emacs. Latest version is 1.31. Designed primarily
                  for LPMUDs and Dikus. Features include screen mode,
                  auto-login, macros, triggers, autonavigator, and it is
                  programmable.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
                  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients

  TINT            Runs on VMS with MultiNet networking. Latest version is 2.2.
                  Designed primarily for TinyMUD-style muds. Features include
                  hiliting (whispers, pages, users), gags, file uploading,
                  simple macros, screen mode. See also TINTw.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
                  ucbvax.berkeley.edu(128.32.133.1):/pub/games/VMSclients

  TINTw           Runs on VMS with Wollongong networking. See TINT.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
                  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients
                  ucbvax.berkeley.edu(129.32.133.1):/pub/games/VMSclients
  
  DINK            Runs on VMS with either Wollongong or MultiNet networking.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
                  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients
                  ucbvax.berkeley.edu(129.32.133.1):/pub/games/VMSclients

  FooTalk         Runs on VMS with MultiNet networking and BSD Unix. Primarily
                  designed for TinyMUD-style muds. Features include screen
                  mode, and it is programmable. See RispTalk below.
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients
                  ucbvax.berkeley.edu(129.32.133.1):/pub/games/VMSclients

  RispTalk        Runs on BSD Unix. FooTalk with an interpreter for converting
                  a lispish language into footalk's language. See FooTalk above.
                  NO KNOWN SITE

  REXXTALK        Runs on IBM VM. Latest version is 2.1. Designed primarily
                  for TinyMUD-style muds. Features include screen mode,
                  logging, macros, triggers, hilites, gags, and auto-login.
                  Allows some IBM VM programs to be run while connected to
                  a foreign host, such as TELL and MAIL. (Warning: Ftp-ing
                  the module sometimes does not work. Try emailing 
                  SESPC381@YSUB.YSU.EDU or SESPC381@YSUB.BITNET and he
                  should be able to send you the module via bitnet.)
                  ftp.math.okstate.edu(139.78.10.6):/pub/muds/clients

  MUDDweller      Runs on any Macintosh. Latest version is 1.1d4. Connects
                  to a MUD through either the communications toolbox or
                  by MacTCP. Usable for both LPMUDs and TinyMUD-style muds.
                  Current features include multiple connections, a command
                  history and a built-in MTP client for LPMUDs.
                  rudolf.ethz.ch(129.132.57.10):/pub/mud
                  sumex-aim.stanford.edu(36.44.0.6):/info-mac/comm
                  mac.archive.umich.edu(141.211.164.153):
                      /mac/utilities/communications
                  wuarchive.wustl.edu(128.252.135.4):/mirrors/info-mac/comm

  MUDCaller       Runs under MSDOS. Latest version is 1.00. Requires an
                  Ethernet card, and uses the Clarkson Packet drivers.
                  Does NOT work with a modem. (If you telnet in MSDOS,
                  you can probably use this.)
                  ferkel.ucsb.edu(128.111.72.60):/pub/mud/clients
                  wuarchive.wustl.edu(129.252.135.4):/pub/MSDOS_UPLOADS

  BSXMUD Clients  These clients run on various platforms, and allow the
                  user to be able to see the graphics produced by BSXMUDs.
                  For more information, contact vexar@watserv.ucr.edu.
                  For Amiga: requires a modem - amigaclient.lzh
                  For PC: requires a modem - msclient.lzh AND x00v124.zip
                  For X11: sources, version 3.2 - bsxclient.tar.Z
                  For Sun4: binary - client.sparc.tar.Z
                  Also available are programs to custom-draw your
                  own graphics for a BSXMUD: - muddraw.tar.Z
                  lysator.liu.se(130.236.254.1):pub/lpmud/bsx
		  ftp.math.okstate.edu(139.78.10.6):pub/muds/BSXstuff

  A few quick definitions:
    Auto-login -- Automatically logs into the game for you.
    Hiliting -- Allows boldface or other emphasis to be applied to some
  text.  Often allowed on particular types of output (e.g. whispers), or
  particular users.  "Regexp" means that UNIX-style regular expressions
  can be used to select text to hilite.
    Gag -- Allows some text to be suppressed.  The choice of what to
  suppress is often similar to hiliting (users or regular expressions).
    Macros -- Allows new commands to be defined.  How complex a macro
  can be varies greatly between clients; check the documentation for
  details.
    Logging -- Allows output from the MUD to be recorded in a file.
    Cyberportals -- Supports special MUD features which can automatically
  reconnect you to another MUD server.
    Screen Mode -- Supports some sort of screen mode (beyond just scrolling
  your output off the top of the screen) on some terminals.  The exact
  support varies.
    Triggers -- Supports events which happen when certain actions on the
  MUD occur (e.g. waving when a player enters the room).  (This can
  nearly always be trivially done on programmable clients, even if it
  isn't built in.)
    Programmable -- Supports some sort of client-local programming.
  Read the documentation.

  Some of these clients are more featured than others, and some require
  a fair degree of computer literacy.  TinyTalk and TinyFugue are
  among the easiest to learn; Tcltt is more professional.  Caveat Emptor.
  Since many MUDders write their own clients, this list can never be
  complete.  As above, ask around.

"Is there any problem with running a client?"

  Not usually.  Clients can be large when compiled, especially if they
  have lots of nifty features.  They don't take up much CPU time at all.
  It is recommended that you ask your friendly systems administrator or
  other machine-responsible person if it's okay for you to install one
  on the system, if only for the reason that someone else might already
  have done so, and you might be able to save space by sharing with them.
  If there's a no games policy at your site, don't try to sneak by it with
  a client -- their activities are easily detectable.  Be good.

"Okay, I know a client is that which connects to a server.  What is a server?"

  ...That which is connected to by a client.  A server is a program which 
  accepts connections, receives data, mulls it over, and sends out some
  output.  In the MUD world, the server keeps track of the database, the
  current players, the  rules, and sometimes the time (or the 'heartbeat').
  Servers are usually very large C programs which maintain a small-to-enormous
  database of the objects, rooms, players and miscellany of the MUD. 
  Because of their size and their constant computational activities, servers
  can be extremely CPU-intensive and can even be crippling to any other work
  done on that computer.  Do not ever run a MUD server on a machine illicitly
  or without express permission from the person responsible for the machine.
  Many universities and companies have strict policies about that sort of
  behavior which you don't want to cross.

  Of course, people who don't know any better start up illicit MUDs all the
  time.  Apart from the possibility of losing all your work and energy to
  one press of a sysadmin's finger, there's no harm done to the player.
  But we must stress: running a MUD where you shouldn't can get you into
  a whole new world of hurt.  Don't take the chance, it's not worth it.

->  SEE ALSO: Frequently Asked Questions post #1.

"Are there lots of different kinds of MUD servers?"

  There are probably as many MUD server types as there are MUDs.  Since
  everyone has their own opinions as to what MUDs should be like, and since
  the server source can be edited, most MUDs have site-specific fixtures
  in them.  However, there are a few main protoMUDs (also called 'vanilla
  versions' because they haven't been 'flavored' yet).  Note that this
  list is not complete, and that it may contain errors in fact or
  judgement, but is deemed pretty much right as of this writing.
  Corrections/additions are welcomed.  

  There are essentially three groups of muds: 
        o  Combat-oriented MUDs (LP/Diku/etc)
        o  TinyMUD and its direct descendants
        o  Miscellaneous

  The majority of the muds in the miscellaneous category are not 
  combat-oriented muds at all, and indeed many take after TinyMUD in most
  things. However, as these muds are not a direct derivative of the original
  TinyMUD code, I've stuck them in their own category.  The authors
  listed for each server are very probably not the people currently
  working on that code.  To find out who's currently in charge of
  the code, either ftp the latest version and look for a README
  file, or ask around.

  Combat-Oriented MUDs
  --------------------

MUD             The original, by Richard Bartle and Roy Trubshaw, written back
                in 1979.  Not available any more.

AberMUD         One of the first adventure-based MUDs.  Players cannot build.
                In later versions, I believe, a class system was added, and
                wizards can build onto the database.  It's named after
                the university at which it was written, Aberstywyth.
                Latest version is 5.16.4, which is only available via signed
                paper licenses, which exclude the author from any liability.
                Not too big, and it will run under BSD, SYSV, and AmigaDOS.
                NO KNOWN SITE (and no known author address)

LPMUD           The most popular combat-oriented MUD.  Players cannot build.
                Be warned, though: LPMUD servers version 3.* themselves are
                very generic - all of the universe rules and so forth are
                written in a separate module, called the mudlib.  Most
                LPMUDs running are written to be some sort of combat system,
                which is why I've classified them here, but they don't
                have to be!  Wizards can build onto the database, by means
                of an object-oriented C-like internal language called LP-C.
                It's named after its primary author, Lars Penj|.  Latest
                version is 3.1.1.  Fairly stable, and size varies from
                medium to large.
                alcazar.cd.chalmers.se(129.16.48.100):/pub/lpmud
                lysator.liu.se(130.236.254.1):/pub/lpmud
                worf.tamu.edu(128.194.51.189):/pub/lpmud
                calvin.nmsu.edu(128.123.35.150):/pub/mud/src
                netserv1.its.rpi.edu(128.113.1.5):/pub-write/lpmud
                ucbvax.berkeley.edu(128.32.133.1):/pub/games/lpmud

                There is a port of 3.1.2 for MSDOS, that requires at least
                a '386 to run.  It accepts connections from serial ports.
                foof.dorm.clarkson.edu(128.153.48.3):/MsdosMUD/lpmud
                alcazar.cd.chalmers.se(129.16.48.100):/pub/lpmud/msdos

                There is a port of 3.1.2 for Amigas, called amud.  Binaries
                and source are available.
                alcazar.cd.chalmers.se(129.16.48.100):/pub/lpmud/amud

DikuMUD         Newer than LPMud, and gaining in popularity.  Almost identical
                from the players' point of view.  Uses a guild system instead
                of a straight class system.  Different classes get different
                tricks specific to that class at various levels.  Wizards
                can add on to the database, but there is no programming
                language, as in LP.  It's named after the university at 
                which it was written.
                coyote.cs.wmich.edu(141.218.40.40):/pub/Games/Diku
                ucbvax.berkeley.edu(128.32.133.1):/pub/games/dikumud

KMUD            Still under development.  KMUD is similar to LPMUD in
                feel, but only runs on PCs.  It does have some on-line
                building commands.  It accepts connections from serial
                ports (requires a FOSSIL driver), and through TCP/IP
                telnet protocol.  Beta versions (with source code)
                are available.
                foof.dorm.clarkson.edu(128.153.48.3):/MsdosMUD/kmud

1001            Still partially in development.  1001 is similar to
                DikuMUD in feel and design, but runs only on PCs.
		Multitasking is required, and a '386 is recommended.
		It's designed for use primarily with multiline BBS
		systems, and supports most BBS software.
                Author is Jim Dugger. Latest version is 1.03.
		Available on FidoNet 1:3814/2, as well as
                ftp.math.okstate.edu(139.78.10.6):/pub/muds/servers


  TinyMUD-style MUDs
  ------------------

TinyMUD         The first, and archetypical, socially-oriented MUD.  It
                was inspired by and looks like the old VMS game Monster,
                by Rich Skrenta.  Players can explore and build, with the
                basic @dig, @create, @open, @link, @unlink, @lock commands.
                Players cannot teleport, and couldn't use @chown or set 
                things DARK until later versions.  Recycling didn't exist
                till the later versions, either.  It's called 'Tiny'
                because it is - compared to the combat-oriented MUDs.
                Original code written by Jim Aspnes.  Last known version
                is 1.5.5.  Not terribly big, and quite stable.
                ftp.math.okstate.edu(139.78.10.6):/pub/muds/servers
                impaqt.drexel.edu(129.25.10.3):
                    /pub/files/unix/games/MUD/tinymud
        
                There is a PC port of TinyMUD, along with some extra
                code.  It accepts connections from serial ports.
                foof.dorm.clarkson.edu(128.153.48.3):/MsdosMUD/tiny

                There is a modified version of TinyMUD called PRISM,
                that works for PCs, Atari STs, and most Unixes. It
                also comes with a internal BSX client for MSDOS.
                lister.cc.ic.ac.uk(129.31.80.167):/pub/prism

TinyMUCK v1.*   The first derivative from TinyMUD.  Identical to TinyMUD,
                except that it added the concept of moveable exits, called
                @actions.  Also introduced the JUMP_OK flag, which allows
                players to use @teleport, and @recycle, which TinyMUD later
                added.  Its name, MUCK, is derived from MUD, and means
                nothing in particular.  Original code written by Stephen
                White.  Latest stable verion is 1.2.c&r, which brought
                TinyMUCKv1 up to date with later TinyMUD things.  Not
                terribly big.
                ftp.math.okstate.edu(139.78.10.6):/pub/muds/servers

TinyMUSH        The second derivative from TinyMUD.  Also identical to TinyMUD,
                with the addition of a very primitive script-like language.
                Introduced JUMP_OK like TinyMUCK, and has recycling, except
                it is called @destroy.  Also introduced the concept of
                PUPPETs, and other objects that can listen.  In later
                versions the script language was extended greatly, adding
                math functions and many database functions.  In the latest
                version, 2.0, it's gone to a disk-basing system as well.
                Its name, MUSH, stands for Multi-User Shared Hallucination.
                Original code written by Larry Foard.  The latest non-
                disk-based version is PennMUSH1.19, which is quite similar
                to 2.0 from the user's point of view.  Both the disk-based
                version and the non-disk-based version are being developed
                at the same time.  TinyMUSH is more efficient in some ways
                than TinyMUD, but winds up being larger because of programmed
                objects.  Version 2.0 in general uses less memory but a 
                great deal more disk space.  Quite stable.
                primerd.prime.com(129.122.132.150):/pub/games/mud/tinymush
                caisr2.caisr.cwru.edu(129.22.24.22):/pub/mush
                foof.dorm.clarkson.edu(128.153.48.3):/Mush
                foof.dorm.clarkson.edu(128.153.48.3):/Pern
                ferkel.ucsb.edu(128.111.72.60):/pub/mud/mush

TinyMUCK v2.*   TinyMUCKv1.* with a programming language added.  The language,
                MUF (multiple user forth), is only accessible to people with
                the MUCKER flag.  Changed the rules of the JUMP_OK flag
                somewhat, to where it's nice and confusing now.  MUF is
                very powerful, and can do just about anything a wizard can.
                Original version 2.* code written by Lachesis.  Latest
                version is 2.2, with several varieties (the most common
                and arguably the most advanced being 2.2.10.4d).
                Newer version with combined goodies from all the varieties
                expected out soon.  Can be quite large, especially with
                many programs.  Mostly stable.
                ferkel.ucsb.edu(128.111.72.60):/pub/mud/tinymuck

TinyMUSE        A derivative of TinyMUSH.  Many more script-language
                extensions and flags. Reintroduced a class system, 
                a-la combat-oriented MUDs.
                Latest version is 1.4, but it's not very stable. 
                chezmoto.ai.mit.edu(18.43.0.102):/tinymuse
                foof.dorm.clarkson.edu(128.153.48.3):/Muse

TinyMAGE        The bastard son of TinyMUSH and TinyMUCK.  It combines
                some of MUSH's concepts (such as puppets, @adesc/@asucc,
                several programming functions, and a few flags) with
                TinyMUCK2.x.  Interesting idea, really busted code. 
                Latest version is 1.0.3.
                ferkel.ucsb.edu(128.111.72.60):/pub/mud/incoming


  Miscellaneous
  -------------

UberMUD         The first MUD where the universe rules are written
                totally in the internal programming language, U.  The
                language is very C/pascal-like.  The permissions system
                is tricky, and writing up every universe rule (commands
                and all) without having big security holes is a pain.
                But it's one of the most flexible muds in existance.
                Great for writing up neat toys.  It's also disk-based.
                Original code written by Marcus J Ranum.  Latest version
                is 1.13.  Small in memory, but can eat up disk space.
                Quite stable.
                decuac.dec.com(192.5.214.1):/pub/mud
                ftp.white.toronto.edu(128.100.2.160):/pub/muds/uber

MOO             An Object-Oriented MUD.  Unfortunately, the first few
                versions weren't fully object oriented.  Later versions
                fixed that problem.  There is a C-like internal programming
                language, and it can be a bit tricky.  Original code
                written by Stephen White.  Last version is 2.0a. 
                NO KNOWN SITE

LambdaMOO       A derivative of MOO.  Added some features and stability.
                Latest version is 1.5.9.
                parcftp.xerox.com(13.1.64.94):/pub/MOO

TeenyMUD        A TinyMUD clone, written from scratch.  Its main feature
                is that it is disk based.  Original code written by
                Andrew Molitor.  Latest version is 1.3a.  Very small,
                and mostly stable.
                fido.econ.arizona.edu(128.196.196.1):/pub

SMUG            Also known as TinyMUD v2.0.  It has an internal programming
                language, and it does have some inheritance.  Surprisingly
                similar to MOO in some ways.  SMUG stands for Small Multi
                User Game. Original code written by Jim Aspnes.
                impaqt.drexel.edu(129.25.10.3):/pub/files/unix/games/MUD/smug
                ferkel.ucsb.edu(128.111.72.60):/pub/mud/smug
                wuarchive.wustl.edu(128.252.135.4):
                    /pub/archives/comp.sources.games/vol11/tinymud2

UnterMUD        A network-oriented MUD.  It's disk-based, with a variety
                of db layers to choose from.  An UnterMUD can connect
                directly to other UnterMUDs, and players can carry
                stuff with them when they tour the Unterverse.  This can
                be a bit baffling to a new user, admittedly, but those
                people already familiar with the old cyberportals and
                how they work (invented way back with the original TinyMUD)
                will adjust to the new real cyberportals easily.  There
                is both a primitive scripting language and much of the
                U language from UberMUD built in, as well as a combat
                system that can be compiled in if wanted.  The parsing
                can be a bit odd, especially if you're used to the
                TinyMUD-style parser.  Unter is also the only MUD that
                can run under BSD Unix, SysVr4 Unix, and VMS with MultiNet
                networking, with little to no hacking.  Original code 
                written by Marcus J Ranum.
                Latest version is 2.1.  Small in memory, but can eat up
                a lot of disk space.
                ftp.math.okstate.edu(139.78.10.6):/pub/muds/servers
                decuac.dec.com(192.52.214.1):/pub/mud
                ferkel.ucsb.edu(128.111.72.60):pub/mud/unter

  Note: just because we say something's available doesn't mean we have it.
  Please don't ask us; ask around for ftp sites that might have them, or
  try looking on ferkel.ucsb.edu (128.111.72.60).


"My [client, server] won't compile!  What do I do?"

  Your first best bet is to check out the documentation and see if someone
  is listed as 'supporting' (i.e. generally responsible for) the program.
  If they are, send them a short, well-written e-mail note explaining your
  hardware and software completely as well as a transcript of the error.
  Do not post to the internet unless all other realistic options have been
  considered and taken -- generally speaking, most readers will not be
  interested in your dilemma and may get upset that you're wasting their
  time.  Since MUDs have probably been compiled on every single platform
  since the Cyber 3000, there's a good chance that asking around the
  subculture will get you the answers you crave.  Do not mail me.  I
  probably won't know.

"What's a cyborg, and should I be one?"

  A cyborg is defined as 'part man, part machine.'  In the MUD world, this
  means that your client is doing some of the work for you.  For instance,
  you can set up many clients to automatically greet anyone entering the
  room.  You can also set up clients to respond to certain phrases (or
  'triggers').  Of course, this can have disastrous consequences.  If 
  Player_A sets his client up to say hi every time Player_B says hi, and
  Player_B does likewise, their clients will frantically scream hi at each
  other over and over until they manage to escape.  Needless to say, runaway
  automation is very heavily frowned upon by anyone who sees it.  If you
  program your client to do anything special, first make sure that it cannot
  go berserk and overload the MUD.

"So I should read the documentation of whatever client I select?"

  Yes.

-------------------------------------------------------------------------------
  This posting has been generated as a public service.  If you have any
  suggestions, questions, additions, comments or criticisms concerning this
  posting, contact either Moira (jds@math.okstate.edu) or cthonics
  (fortony@sonne.cso.uiuc.edu).  Other Frequently Asked Questions (FAQ)
  postings contain information on MUDs, MUDding, and RWHO.  While these 
  items aren't necessary, they make the game much more playable.  We'd like
  to thank IronThoughts and Tarrant for their help in writing this FAQ, and
  everyone else for helpful comments and suggestions.  The most recent
  versions of these FAQs are archived on ftp.math.okstate.edu (139.78.10.6)
  in pub/muds/misc/mud-faq, plus on rtfm.mit.edu (18.172.1.27), in the 
  news.answers archives.  Have fun!  - Moira and cthonics

-- 
Jennifer Smith
jds@math.okstate.edu
On MUDs: Moira, RosaLil, Jasra, etc.	      |   It's the terror of knowing
Here, have a clue. Take two, they're small.   |    What this world is about
Newsgroups: rec.games.mud,rec.games.mud.misc