[2-1] Free Scheme implementations.
Repositories of Scheme source code are described in the answer to
question [1-9].
Remember, when ftping compressed or compacted files (.Z, .z, .arc, .fit,
etc.) to use binary mode for retrieving the files.
Files that end with a .z suffix were compressed with the patent-free
gzip (no relation to zip). Source for gzip is available from:
prep.ai.mit.edu:/pub/gnu/
as the files gzip-1.2.4.shar, gzip-1.2.4.tar,or gzip-1.2.4.msdos.exe.
Repositories of Scheme implementations:
Many free Scheme implementations are available from swiss-ftp.ai.mit.edu
[18.43.0.246]. See also the Scheme Repository described below.
The Scheme Repository contains a Scheme bibliography, copies of the
R4RS report, sample Scheme code for a variety of purposes, several
utilities, and most free implementations. (Implementations of Scheme
available from the repository include elk, gambit, scm, fools, rabbit,
s48, scheme84, scheme88, pseudo, xscheme, umb-scheme, siod, vscm, and
pixiescheme.) The repository was established by Ozan S. Yigit and
is currently maintained by David Eby and John Zuckerman
<scheme-repository-request@cs.indiana.edu>. The repository is
accessible by anonymous ftp at
ftp.cs.indiana.edu:/pub/scheme-repository/ [129.79.254.191]
The repository is mirrored in INRIA, courtesy of Christian Queinnec
[Ecole Polytechnique and INRIA-Rocquencourt], ftp.inria.fr:/lang/Scheme.
(See also [1-9].)
Scheme implementations:
BIGLOO is a Scheme interpreter and compiler. It conforms to the
IEEE-Scheme standard (IEEE P1178) with some extensions, such as
regular expression parsing (RGC), a lexical analyzer generator, a full
foreign function interface, and a pattern matching compiler. Bigloo
can also compile modules written in Caml (an ML dialect), letting you
mix Scheme, ML, and C. Object-oriented programming is provided by
Meroon v3. The main goal of Bigloo is to deliver small and fast stand
alone applications. Bigloo produces ANSI C and hence should be easy
to port. It runs on Sparc (1, 2, 10), SONY-NEWS (MIPS R3000), IRIS
Indigo (MIPS R3000), Sun 3/60, DecStation 3100, PC-486 (linux), and
HP-PA (730). It is available by anonymous ftp from
ftp.inria.fr:/INRIA/Projects/icsla/Implementations/ [192.93.2.54]
as the files bigloo1.7.tar.gz and camloo0.2.tar.gz.
For further information, send email to Manuel.Serrano@inria.fr, or
write to Manuel Serrano (equipe ICSLA, Bat 8), INRIA-Rocquencourt,
BP 105, 78153, Le Chesnay CEDEX, FRANCE, or call 39-63-57-32.
Elk (Extension Language Kit) has been designed specifically as an
embeddable, reusable extension language subsystem for applications written
in C or C++. Elk is also useful as a stand-alone Scheme implementation,
in particular as a platform for rapid prototyping of X11-based Scheme
programs. Elk was first published in 1989; the current version is Elk 3.0.
The Elk distribution includes a Scheme interpreter (embeddable and
stand-alone versions), several dynamically loadable extensions, run-time
support (including a top-level implemented in Scheme and a debugger),
and 230+ pages of documentation (troff and PostScript format).
Major features of Elk are incremental, dynamic loading of compiled
extensions (supported on many platforms); freezing of the interpreter or
application into a new executable file; a C/C++ programmer's interface
for language interoperability; Scheme bindings for X11 Xlib, Xt, Athena
and Motif Widgets; a UNIX interface (not restricted to POSIX); bitstrings,
records, and regular expressions; a stop-and-copy and an incremental,
generational garbage collector.
The Elk 3.0 distribution and more information about Elk are available
in the World Wide Web at
http://www.informatik.uni-bremen.de/~net/elk
The distribution is also available on a number of FTP sites including
ftp://ftp.x.org/contrib/devel_tools/elk-3.0.tar.gz
ftp://ftp.uni-bremen.de/pub/programming/languages/scheme/elk/elk-3.0.tar.gz
For more information contact Oliver Laumann <net@cs.tu-berlin.de>.
FDU Scheme is a R3RS implementation of Scheme for the Prime
50-series under Primos. It is available by anonymous ftp from
fdumad.fdu.edu [132.238.1.1] (username "anonymous", password
<RETURN>). Attach to the Scheme subdirectory (cd '*>scheme') and
transfer all files in it and its subdirectories using file type
binary. For more information, contact Peter Falley,
<falley@fdumad.fdu.edu>.
Fools' Lisp is a small Scheme interpreter that is R4RS conformant, and
is available by anonymous ftp from
scam.berkeley.edu:/pub/src/local/fools.1.3.2.tar.Z [128.32.138.1]
Fools' Lisp runs on Sun3 and Sun4 (SunOs), DecStation 3100s, Vax
(Ultrix), Sequent, and Apollo. Implemented by Jonathan Lee
<jonathan@scam.berkeley.edu>.
Gambit is a high-performance implementation of Scheme based on an
optimizing compiler. It conforms to the IEEE-Scheme standard (IEEE
P1178) and the Revised^4 Report on Scheme (R4RS) and supports the
whole numeric tower (i.e. integer, rational, real and complex numbers).
Gambit extends the standards by providing: weak pairs, wills, string
ports, records, property lists, namespaces, futures, pretty printer,
debugger, multitasking, and compiler declarations. To make it portable
and simplify bootstrapping, the compiler is written in IEEE-Scheme and
makes use of a high-level abstract-machine (called GVM) for the
intermediate representation. A "Scheme-in-Scheme" approach was adopted
to minimize the amount of non-portable code in the system (nearly all of
the runtime library is written in Scheme including the interpreter and
debugger). Three different variants of Gambit were produced:
Gambit-68K (first public release in 1990; last version: 2.0, june 1993):
This is the original Gambit system with a native code back-end
for Motorola 680x0. It works on most 68K based Unix workstations
and on the BBN GP1000 shared-memory multiprocessor. The back-end
for the GP1000 implements Multilisp's "future" parallel construct
using lazy-task-creation (a very low overhead task spawning
mechanism).
ftp.iro.umontreal.ca:/pub/parallele/gambit/gamb68k.tar.Z
MacGambit (first public release in 1991; last version: 2.2.2, oct 1995):
This is a port of Gambit-68K for the Macintosh. It is a complete
development environment, including a Scheme-aware editor, an online
help system, and a linker to build standalone applications. A
drawing window for simple graphics and an interface to many of the
Macintosh's "Toolbox" routines are available. An executable
MacGambit application is supplied with the distribution as well as
all the sources (ThinkC 4.0 or CodeWarrior 6 or higher are needed to
recompile the sources).
ftp.iro.umontreal.ca:/pub/parallele/gambit/MacGambit.sea.hqx
Gambit-C (first public release in 1994; last version: 2.3.1, april 1996):
In this variant of Gambit, the compiler generates highly portable
C code that is reasonably efficient. The primary goals of Gambit-C
are portability and correctness (in particular it correctly implements
tail-recursion across modules and uses a precise garbage-collector).
Gambit-C runs on a wide range of Unix workstations, on Macintosh, and
DOS/Windows. It also supports these features: dynamic-loading
of compiled files, C-interface (FFI), and a memory management system
that expands and contracts the heap based on the program's needs.
Standalone executables can be created with Gambit-C (a minimal
application is about 700 Kbytes when statically linked and 5 Kbytes
when the runtime system is compiled as a shared-library).
Sources:
ftp.iro.umontreal.ca:/pub/parallele/gambit/gambc.tar.gz
Executables for Windows-95 and Windows-NT:
ftp.iro.umontreal.ca:/pub/parallele/gambit/gambc.zip
Executables for DOS and Windows 3.1:
ftp.iro.umontreal.ca:/pub/parallele/gambit/gambcdos.zip
Gambit can be used freely for non-commercial uses (including academic
research and education). A license is required to use Gambit
commercially (contact gambit@iro.umontreal.ca).
HELP (a lazy Scheme) is available by anonymous ftp from
sumex-aim.stanford.edu:/info-mac/lang/lazy-scheme.hqx. Written by
Thomas Schiex (schiex@cert.fr, schiex@irit.fr). Help is a complete and
efficient Scheme-like functional lazy Lisp interpreter. It works only
on 68020 (or more) based Macintoshes. It has a 'friendly' interface
(parenthesis matcher, auto-indent), uses a full call-by-need semantics
and includes many examples, including a symbolic compiler for the
680x0. Efficiency is good and lazyness is fully parametrizable (you
may turn Help into a strict Scheme-like language if you like). French
AND English updated docs are included in Word4 and plain text formats.
LIBSCHEME is a C library implementing Scheme as described in R4RS. It
is easily integrated into a C program as a command interpreter or
extension language, and is easily extended in C with new primitive
types, primitve functions and syntax. It should be portable to most
machines with an ANSI C compiler. It is available by anonymous ftp
from
ftp.cs.indiana.edu:/pub/scheme-repository/imp/
For more information, write to Brent Benson
<bwb@concentra.com>.
MIT Scheme (aka C-Scheme), is available free by anonymous FTP from
swiss-ftp.ai.mit.edu:/archive/scheme-7.3 [18.23.0.16]
or
ftp.cs.indiana.edu:/pubscheme-repository/imp/MIT-Scheme-7.3/doc
Version 7.3 is a beta version and runs on DEC Alpha, DECStation
(MIPS), HP 9000 300/400/700, IBM RS-6000, Intel i386/i486 (DOS, NT,
Windows 3.1, or Linux), NeXT (NeXTOS 2 or 3), SGI (MIPS), Sony NEWS
(MIPS), Sun3 (SunOS 4.1) and Sun4 (SunOS 4.1). Bugs should be
reported to bug-cscheme@martigny.ai.mit.edu (for the DOS version, send
bug reports to bug-cscheme-dos@martigny.ai.mit.edu). MIT Scheme
includes Edwin (Scheme's Emacs-like editor) and Liar (the Scheme
compiler). Does not have a convenient foreign function interface yet.
FTP distribution includes MIT C-Scheme Reference and User manuals, as
well as the Revised^4 Report on Scheme. Discussion occurs on the
newsgroup comp.lang.scheme.c (gatewayed to the mailing list
info-cscheme@zurich.ai.mit.edu). For DOS floppy distribution requests
(includes printed copies of manuals), send $95.00 (payable in U.S.
funds to "Scheme Distribution") to cover costs of distribution to
Scheme Distribution, c/o Prof. Hal Abelson, 545 Technology Sq. rm 410,
Cambridge MA 02139, USA.
|
On the NeXT, MIT Scheme is available as part of the Schematik
package, which provides an editor/front-end user interface,
graphics, and "robotics" support for Lego and the like. Schematik is
free and is available for anonymous ftp from
ftp.gac.edu:/pub/next/scheme/
Europeans can get it more locally from
ftp.informatik.uni-muenchen.de:/pub/next/ProgLang/
start with Schematik-1.1.5.1.README . Schematik is also apparently
included on NeXT's "Educational Software Sampler" CD-ROM.
|
A preliminary unofficial port of C-Scheme to the Linux is available
from artemide.dei.unipd.it:/linux/scheme-7.2/. Contact the author
Matteo Frigo <Matteo.Frigo@dei.unipd.it> for more information.
MzScheme is a Scheme implementation for Unix, Windows (Win32), and
MacOS. In addition to supporting standard R4RS Scheme (including the
full numerical tower), MzScheme provides pre-emptive threads,
generative record datatypes, an exception system (integrated with all
primitive errors), classes and objects, first-class compilation units,
regular expression parsing, and simple TCP support on all platforms.
MzScheme can dynamically load extensions implemented in C, and it
can be embedded into any C/C++ application. Interoperability with C is
facilitated by the use of a conservative garbage collector.
MzScheme is the core interpreter for MrEd, an engine for developing
portable GUI applications for X Windows, Windows, and MacOS. DrScheme
(currently under development, using MzScheme/MrEd) will incorporate
project management, debugging, and modular analysis to provide a
complete Scheme development environment for pedagogical and
professional use.
For information and online documentation for MzScheme, MrEd, and
DrScheme, see
http://www.cs.rice.edu/CS/PLT/packages/drscheme/
Oaklisp is an seamless integration of Scheme with an object-oriented
substrate. Available by anonymous ftp from
f.gp.cs.cmu.edu:/usr/bap/oak/ftpable/ [128.2.250.164]
or from
ftp.cs.cmu.edu:/afs/cs.cmu.edu/user/bap/oak/ftpable/
and includes reference and implementation manuals. Written by Barak
Pearlmutter <bap@cse.ogi.edu> and Kevin Lang <kevin@research.nj.nec.com>.
PC-Scheme (aka PCScheme, PC Scheme) is an implementation of Scheme
originally written by Texas Instruments. TI made a version of the
source code freely distributable in 1987. TI stopped supporting
the code, and some researchers at the University of Geneva produced
a cleaned-up version (see PCS/Geneva below). On July 13, 1992, Ibuki
announced that it had purchased the rights to PC Scheme from TI.
Please see the Ibuki PC Scheme entry in [2-2]. If you want a
high-quality and supported implementation of PC Scheme, buy the
Ibuki implementation. It is certainly inexpensive enough. Now TI
PC-Scheme is available by anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/pc-scheme/
and runs on MS-DOS 286/386 IBM PCs and compatibles. Version 3.3
should run on the 486, but no guarantees. Version 3.3 is the last
free version. TI PC-Scheme conforms to the Revised^3 Report on Scheme.
It includes an optimizing compiler, an emacs-like editor, inspector,
debugger, performance testing, foreign function interface, window
system and an object-oriented subsystem. It also supports the dialect
used in Abelson and Sussman's SICP.
PCS/Geneva is a cleaned-up version of Texas Instrument's PC Scheme
developed at the University of Geneva. The main extensions to PC
Scheme are 486 support, BGI graphics, LIM-EMS pagination support, line
editing, mouse support, assembly-level interfacing, and several
powerful Scheme-oriented editors. (TI's PC Scheme gives users full
Revised^3 support along with many primitives for DOS, Graphics and
Text Windows. A powerful built-in optimizing compiler produces fast
code.) PCS/Geneva 4.02PL1 has been tested on XTs, ATs, AT386s and
AT486s under various DOS and OS/2 versions. It even runs on
Hewlett-Packard's HP95LX. It also runs on Suns with a DOS emulator.
PCS/Geneva is available free by anonymous ftp from
cui.unige.ch:/PUBLIC/pcs/ [129.194.70.1]
as the files pcscheme.doc, pcscheme.exe, pcscheme.fil and pcscheme.taz
or by email (uuencoded) from schemege@cui.unige.ch. If you ftp
PCS/Geneva, please send mail to schemege@cui.unige.ch; the authors
like to know their public and will inform you when a new release is
available. This is also the email address for bug reports or if you
need any kind of help. This product may be distributed freely and
used without restrictions except for military purposes.
(PCS/Geneva was developed by Larry Bartholdi <lbartho@cui.unige.ch>
and Marc Vuilleumier <mvuilleu@cui.unige.ch>.)
Pixie Scheme for the Macintosh is a nearly complete implementation of
R3RS available by anonymous ftp from
rascal.ics.utexas.edu:/misc/mac/programming/
Pixie.Goodies.SIT.bin
Pixie.NoFPP.world.SIT.bin
Pixie.world.SIT.bin
PixieScheme.NoFPP.SIT.bin ; for macs without floating-point coprocessor
PixieScheme.SIT.bin ; for macs with FPP
Pixie_Scheme_Help.SIT.bin
Pixie_intro
Written by Jay Reynolds Freeman <freeman@MasPar.COM>, P. O. Box 60628,
Palo Alto, CA, 94306-0628. A copy may also be obtained from
/afs/umich.edu/group/itd/archive/mac/development/languages
as the file pixiescheme.cpt.hqx if your site runs the Andrew File System,
or by anonymous ftp from mac.archive.umich.edu.
Scheme->C is an R4RS compliant Scheme system that is centered around
a compiler that compiles Scheme to C. Besides the base language,
the system includes "expansion passing style" macros, a foreign function
call capability, records, weak pointers, 3 X11 interfaces, call/cc, and a
generational, conservative, copying garbage collector. The result is a
system that is portable, efficient, and able to build applications that
contain a mix of compiled and interpreted Scheme, and compiled code
from C, C++ and other languages. The current release of Scheme->C runs
on the following systems: Digital Alpha AXP systems with OSF/1, MIPS
based DECstations, VAXen with ULTRIX, MIPS based SGI systems, PC's
running Microsoft Windows 3.1, Apple Macintosh's running system 7.1,
HP 9000/300, HP 9000/700, Sony News, Harris Nighthawk and other m88k
systems, linux, Sun SPARC, and NT (Visual C++ compiler). Earlier
releases also run on Sun3, DNx500, DN1000, 386's running Unix,
DNx500, and DN1000 systems. The software is available for
anonymous ftp from
gatekeeper.dec.com:/pub/DEC/Scheme-to-C/ [16.1.0.2]
There are three interfaces to X11, all written in Scheme, available
from gatekeeper. The first is a complete set of stubs to Xlib included
in the base system. The second is an alternative to Xlib called SCIX,
found in
gatekeeper.dec.com:/pub/X11/contrib/
The third, ezd, allows programs to easily
produce interactive, structured graphics and is found in
gatekeeper.dec.com:/pub/DEC/ezd/
Those without ftp access can also obtain Scheme->C and ezd from the
Prime Time Freeware CD, Vol. 1, No. 2. Additional information is
available from the author at Digital Equipment Corporation's Western
Research Lab: Joel Bartlett, bartlett@decwrl.dec.com.
Scheme 48 is a Scheme implementation based on a virtual machine
architecture. Scheme 48 is designed to be straightforward, flexible,
reliable, and fast. It should be easily portable to 32-bit
byte-addressed machines that have POSIX and ANSI C support.
In addition to the usual Scheme built-in procedures and a development
environment, library software includes support for hygienic macros (as
described in the Revised^4 Scheme report), multitasking, records,
exception handling, hash tables, arrays, weak pointers, and FORMAT.
Scheme 48 implements and exploits an experimental module system
loosely derived from Standard ML and Scheme Xerox. The development
environment supports interactive changes to modules and interfaces.
A beta release of Scheme 48 is available by anonymous ftp from
ftp.cs.indiana.edu:/pub/scheme-repository/imp/scheme48-0.36.tar.Z
swiss-ftp.ai.mit.edu:/archive/s48/scheme48-0.36.tar.gz
ftp.cs.cmu.edu:/user/ai/lang/scheme/impl/s48/scheme48.tar.gz
For more information, contact Richard Kelsey and Jonathan Rees
at <scheme-48-request@martigny.ai.mit.edu>.
Scsh is a Unix shell/systems programming environment implemented on top of
Scheme 48 (a portable, byte-code compiled R4RS Scheme implementation). Scsh
provides
- A high-level macro notation for writing typical shell-script
computations: running programs, pipelines, I/O redirection, and so
forth. For example, to decompress a file and mail it to someone,
you might say
(run (| (gzcat home.html.gz)
(mail -h "Here's my home page" shivers@lcs.mit.edu)))
To spell check your paper, printing out the results, you could say:
(run (| (delatex (< paper.tex))
(spell)
(lpr -Ppulp)))
- A complete system-call interface to Unix: fork, exec, I/O, file
system, time, env vars, and so forth. The I/O interface includes
a *complete* interface to BSD sockets, both Unix and TCP/IP domains.
I/O is completely integrated with Scheme ports. System calls return
useful values, not error codes; errors are reported by raising
exceptions which can be caught by handlers.
- Other useful shell-programming utilities: filename globbing/pattern
matching, regexp matching, macros for writing AWK-like programs, field
and record parsers, and so forth.
- The ability to write executable shell scripts using the Unix #!
interpreter feature, with access to command-line argv values.
These features are completely integrated into Scheme 48's R4RS Scheme
implementation; the programming language is Scheme. The scsh release
is self-contained -- it comes with its own complete Scheme 48
implementation. Scsh currently runs on the following platforms: DEC Ultrix,
Harris NightHawk, HP-UX, IBM AIX, Linux, NetBSD/i386, NeXTSTEP/Intel,
SGI IRIX, Solaris, and SunOS. It's not hard to port scsh to new systems.
|
You can get a copy of scsh via anonymous ftp, from the following:
ftp://clark.lcs.mit.edu/pub/su/scsh/scsh.tar.gz
ftp://swiss-ftp.ai.mit.edu/pub/su/scsh/scsh.tar.gz
These tar files include a detailed manual and a paper describing
the design of the system. For the lazily curious, we also have the
manual separately available as
ftp://clark.lcs.mit.edu/pub/su/scsh/scsh-manual.ps
ftp://swiss-ftp.ai.mit.edu/pub/su/scsh/scsh-manual.ps
Scsh has been implemented by the Scheme Underground
http://www.ai.mit.edu/projects/su/su.html
For further information, contact Olin Shivers <shivers@lcs.mit.edu>,
http://clark.lcs.mit.edu/~shivers/home.html
SCM, free by anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/scm/
prep.ai.mit.edu:/pub/gnu/jacal/
ftp.cs.indiana.edu:/pub/scheme-repository/new/
ftp.maths.tcd.ie:/pub/bosullvn/jacal/
Current version 4e1. Runs on Amiga, Atari-ST, MacOS, MS-DOS, OS/2,
NOS/VE, VMS, Unix and similar systems. SCM conforms to the Revised^4
Report on the Algorithmic Language Scheme and the IEEE P1178
specification. Scm is written in C. ASCII and EBCDIC are supported.
Written by Aubrey Jaffer.
To receive an IBM PC floppy disk with the source files and MSDOS
and i386 executables send $99 to Aubrey Jaffer, 84 Pleasant Street,
Wakefield MA 01880, <jaffer@zurich.ai.mit.edu>.
SLIB (Standard Scheme Library) is a portable Scheme library
which is intended to provide compatability and utility functions for
all standard Scheme implementations, including SCM, Chez, Elk,
Gambit, MacScheme, MITScheme, scheme->C, Scheme48, T3.1, and VSCM, and is
available as the file slib2a0.tar.gz. Written by Aubrey Jaffer.
JACAL is a symbolic math system written in Scheme, and is
available as the file jacal1a4.tar.gz.
SCMCONFIG contains additional files for the SCM distribution to build
SCM on Unix machines using GNU autoconf.
SLIB-PSD is a portable debugger for Scheme (requires emacs editor).
TURTLSCM is a turtle graphics package which works with SCM on MSDOS
or X11 machines. Written by Mkinen Sami <sjm@cc.tut.fi> and Jarkko
Leppanen <jtl@cc.tut.fi>, it is available as the file turtlegr.tar.Z.
(Also available from modeemi.cs.tut.fi:/pub/scm/ as turtlegr.tar.gz,
along with an already-compiled MSDOS binary of scm with turtlegraphics
and slib in scm4c0_b.zip.)
XSCM is an X Windows interface to Xlib and the Motif and
OpenLook toolkits for the SCM interpreter. It requires scm4a10 or
later. It should be available at any archive of alt.sources, or on
swiss-ftp, prep and indiana as the file xscm1.05.tar.Z.
Contact campbell@redsox.bsw.com for more information.
SMG-SCM is a package that adds VMS SMG screen management routines
to SCM. It is available from swiss-ftp, prep and indiana as the file
sgm-scm2a1.zip. (A VMS version of Unzip is available by anonymous
FTP from ftp.spc.edu:[ANONYMOUS.MACRO32]UNZIP.EXE.) This file
contains the source code, documentation, and example code. Send
comments and bugs to T. Kurt Bond, <tkb@mtnet2.wvnet.edu> (preferred)
or <Kurt.Bond@launchpad.unc.edu>.
WB is a disk based, sorted associative array C library (database). These
associative arrays consist of variable length (less that 256 bytes)
keys and values. WB comes with an interface to SCM. Basic
operations are creation, destruction, opening and closing of
diskfiles and arrays, insertion, deletion, retrieval, successor, and
predecessor (with respect to dictionary order of keys). Functional
application of find-next, deletion, and modification over a range of
consecutive key values is supported. Multiple associative arrays
can be stored in one disk file. Simultaneous access to multiple
disk files is supported. A structure checker, garbage collector
are included. A repair program and ram-disk type file (for
temporary structures) are in developement. The current WB
implementation has a file size limit of 2^32 * block size (default
2048) = 2^43 bytes (8796 Gbytes). WB does its own memory and disk
management. WB is available on swiss-ftp, prep, and indiana as wb1a1.tar.z.
A Windows version of Scheme called WinScm is forthcoming from
Vincent Manis of Langara College of BC, Canada.
Hobbit is a Scheme-to-C compiler that works with the SCM Scheme
interpreter. It treats SCM as a C library and integrates compiled
functions into SCM as new primitives. Hobbit release 2 works with SCM
release 4b4. Future releases of SCM and Hobbit will be coordinated.
Hobbit imposes strong restrictions on the higher-order features of
Scheme. For example, it does not support continuations. The main aim
of hobbit is to produce maximally fast C programs which would retain
most of the original Scheme program structure, making the output C
program readable and modifiable. Hobbit is written in Scheme and is
able to self-compile. Hobbit can be obtained via anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/scm/hobbit2.tar.Z
prep.ai.mit.edu:/pub/gnu/jacal/hobbit2.tar.Z
ftp.cs.indiana.edu:/pub/scheme-repository/new/hobbit2.tar.Z
For further information, contact the author, Tanel Tammet, at
<tammet@cs.chalmers.se> or at Tanel Tammet, Department of Computer
Sciences, Chalmers University of Technology, S-41296 Go"teborg, Sweden.
Similix is a Self-Applicable Partial Evaluator for a Subset of Scheme.
Written by Anders Bondorf, Olivier Danvy, and Jesper J{\o}rgensen. It
is available by anonymous ftp from
ftp.cs.indiana.edu:/pub/scheme-repository/imp/
as similix.tar.Z or from ftp.diku.dk:/pub/diku/dists/Similix.tar.Z. For
more information, contact Anders Bondorf, DIKU, Department of Computer
Science, University of Copenhagen, Universitetsparken 1, DK-2100
Copenhagen, Denmark, or send email to anders@diku.dk. Similix conforms
to the IEEE and R4RS standards, but also runs under R3RS Scheme. It
runs in SCM, Chez Scheme and T3.1.
SIOD (Scheme in One Defun), free by anonymous ftp from
ftp.cs.indiana.edu:/pub/scheme-repository/imp/siod-v3.0-shar
ftp.std.com:/pub/gjc/siod-3.0-shar
or in any comp.sources.unix archive. Runs on VAX/VMS, VAX UNIX, Sun3,
Sun4, Amiga, Macintosh, MIPS, Cray, Windows NT/WIN32. Small scheme
implementation in C arranged as a set of subroutines that can be
called from any main program for the purpose of introducing an
interpreted extension language. Compiles to ~42K bytes of
executable. Lisp calls C and C calls Lisp transparently. Version
3.0 includes support for manipulation of Oracle and Digital RDB
relational databases (SQL interface).
Written by George Carrette <gjc@paradigm.com> or <gjc@world.std.com>.
STk is a R4RS Scheme interpreter which can access the Tk graphical
package. All of the commands defined by the Tk toolkit are available
to the STk interpreter, and Tk variables are reflected back into
Scheme as Scheme variables. Callback is expressed in Scheme. Includes
a CLOS-like OO extension called STklos, which provides multiple
inheritance, generic functions, multi methods, and a true meta-object
protocol. A set of classes have been defined to manipulate Tk
commands (menu, buttons, scales, canvas, canvas items) as Scheme
objects. STk runs on Sparc (SUNOS 4.1.x), Dec 5xxx (Ultrix 4.2), SGI
(Irix 4.05, 5.1.1), DEC Alpha, and Linux 1.0. STk is available by
anonymous ftp from
kaolin.unice.fr:/pub/STk-2.1.tar.gz [193.48.229.225]
Please send bug reports, comments, and questions to Erick Gallesio,
<eg@unice.fr>, Universite de Nice - Sophia Antipolis, ESSI - I3S
Route des colles, BP 145, 06903 Sophia Antipolis CEDEX, FRANCE,
phone (33) 92-96-51-53, fax (33) 92-96-51-55.
To subscribe to the mailing list, send a message with
subscribe
in the Subject field to stk-request@kaolin.unice.fr.
T3.1 is a Scheme-like language developed at Yale. Available by
anonymous ftp from
ftp.ai.mit.edu:/pub/systems/t3.1/
T may be obtained in Europe from
nic.funet.fi:/pub/unix/languages/scheme/t3.1/
ftp.diku.dk:/pub/t3.1/
Runs on DecStations (MIPS processor) and SGI Iris, Sun4
(SPARC), Sun3, Vax/Unix. Includes a copy of the online version of the
T manual and release notes for T3.0 and T3.1. All implementations
include a foreign function (C) interface. To be informed of fixes, new
releases, etc., send your email address to t-project@cs.yale.edu. Bug
reports should go to t3-bugs@cs.yale.edu. A multiprocessing version of
T (for Encore Multimax) is available from masala.lcs.mit.edu:/pub/mult.
[The sources were last modified November 22, 1991.]
UMB Scheme is a R4RS Scheme available by anonymous ftp from
ftp.cs.umb.edu:/pub/scheme/umb-scheme-2.10.tar.Z and also in the Scheme
Repository. It includes a simple editor, debugger, Written by William
Campbell, University of Massachusetts at Boston, bill@cs.umb.edu.
VSCM is a R4RS Scheme available by anonymous ftp from the Scheme Repository,
ftp.cs.indiana.edu:/pub/scheme-repository/imp/vscmV0r2.tar.Z [130.63.9.66]
Written by Matthias Blume, <blume@cs.princeton.edu>. The
implementation is based on a virtual machine design with heavy support
for most of the sophisticated features of Scheme. The virtual machine
is written in ANSI-C to aid in its portability. The bytecode compiler
is written in Scheme itself. Documentation of VSCM is also available as
http://www.cs.princeton.edu/grad/Matthias_Blume/vscm.html
XScheme is available free by anonymous ftp from
ftp.uu.net:/MSDOS/languages/X-scheme
ftp.uu.net:/amiga-sources/xscheme.20.zoo
It includes an object system and is R3RS compliant.
It was written by David Michael Betz, 167 Villa Avenue #11, Los Gatos,
CA 95032, 408-354-9303 (H), 408-862-6325 (W), dbetz@apple.com.
XScheme is discussed in the newsgroup comp.lang.lisp.x. It may also
be found in the Scheme Repository.
Free Scheme Implementations implemented in Lisp:
Peter Norvig's book "Paradigms of AI Programming" has a chapters about
Scheme interpreters and compilers, both written in Common Lisp. The
software from the book is available by anonymous ftp from
unix.sri.com:/pub/norvig and on disk in Macintosh or DOS format from
the publisher, Morgan Kaufmann. For more information, contact: Morgan
Kaufmann, Dept. P1, 2929 Campus Drive, Suite 260, San Mateo CA 94403,
or call Toll free tel: (800) 745-7323; FAX: (415) 578-0672
PseudoScheme is available free by anonymous ftp from
ftp.cs.cornell.edu:/pub/jar/pseudo-2-9.tar.gz
swiss-ftp.ai.mit.edu:/archive/pseudo/pseudo-2-8.tar.Z
It is Scheme implemented on top of Common Lisp, and runs in Lucid,
Symbolics CL, VAX Lisp under VMS, and Explorer CL. It should be
easy to port to other Lisps. It was written by Jonathan Rees
(jar@altdorf.ai.mit.edu, jar@cs.cornell.edu). Send mail to
info-clscheme-request@mc.lcs.mit.edu to be put on a mailing list
for announcements. Conforms to R4RS except for lacking a correct
implementation of call/cc. It works by running the Scheme code
through a preprocessor, which generates Common Lisp code.
Scheme84 is in the public domain, and available by mail from Indiana
University. It runs on the VAX in Franz Lisp under either VMS or BSD Unix.
To receive a copy, send a tape and return postage to: Scheme84
Distribution, Nancy Garrett, c/o Dan Friedman, Department of Computer
Science, Indiana University, Bloomington, Indiana. Call 1-812-335-9770
or send mail to nlg@indiana.edu for more information. It will also
run in Jeff Dalton's port of Franz Lisp to Net/Free/386BSD on 386-like
machines. (See the Lisp FAQ for information on Franz Lisp.)
Scheme84 is available by anonymous FTP from
ftp://ftp.cs.indiana.edu/pub/scheme-repository/imp/scheme84.tar.gz
Scheme88 is available by anonymous ftp from rice.edu:/public/scheme88.sh
and also from the Scheme Repository.
Go Back Up
Go To Previous
Go To Next