Gwydion Dylan

Gwydion Dylan is freely available implementation of a dynamic language strongly resembling the language defined in the Dylan Reference Manual. Gwydion Dylan differs in a number of ways from the official language definition, see d2c limitations, Mindy v.s. Dylan and extensions. See the copyright notice for the conditions under which Gwydion Dylan is made available.

DylanTM is a trademark of Apple Computer Corp.

Gwydion Dylan provides two different execution engines:

d2c
An optimizing Dylan to C compiler which offers reasonably good runtime speed, but compilations are relatively slow and debugging facilities are less convenient that in Mindy.
Mindy
A byte-code compiler which offers extremely fast compilation, reasonably good debuggability, and slow runtime speed. Mindy is also somewhat more portable, and is available on more platforms. This is an update of our earlier Mindy releases.

Binary Distributions

The last CMU release of Gwydion Dylan is version 2.0. d2c for Unix is now being supported by a net community based at http://www.randomhacks.com/dylan. They might have newer versions and different platforms available. See the change log for information on differences between 2.0 and previous releases. We have binary distributions built on the following platforms:

These ports of Gwydion Dylan or bare Mindy are also available at other sites:

Support and Disclaimer

This software is made available "as is". Neither the authors nor Carnegie Mellon University make any warranty whatsoever concerning the software, its performance, or its conformity to any specification.

Gwydion is a small research project, and most of our effort in the near future will be devoted to developing a "hypercode" programming environment. The amount of time and effort we can put into supporting this release is extremely limited. We will try to answer mail to gwydion-bugs@cs.cmu.edu , but we can't guarantee that our replies will be timely or that we will fix every bug reported. We are releasing the Gwydion Dylan source so that users can fix things for themselves if they choose to do so. We encourage users to send improvements and bug-fixes to us so that we can add them to future releases.

Documentation

Documentation for Gwydion Dylan is available on the web. A html distribution is also available if you want a local mirror. See also the draft DRM .

Source availability

The sources to Gwydion Dylan are available in gd20-source.tar.gz. You can also browse the sources. See the copyright notice on Gwydion Dylan for the terms under which the sources are made available. See build instructions for information on how to rebuild from the sources.

Requirements

The Mindy byte-interpreter is significantly more portable than the d2c compiler. Since mindycomp is written in C, and Mindy makes thorough use of autoconf to conditionalize itself, it can be easily compiled from sources on a wide range of Unixes. To compile Mindy from sources, see the build instructions.

In contrast, d2c is a bootstrapped system, written almost entirely in Dylan, and has been explicitly configured to run on a set of known platforms. Though it is possible to rebootstrap via Mindy, and the configure script will attempt to do so if a d2c binary is not found, in practice you don't want to do this, as it takes nearly forever. So if you want to run d2c, you need a binary distribution. Once you have the binary distribution, you can recompile d2c from sources if you want. An additional d2c portability limitation comes from the use of the Boehm conservative GC; sources are included, but it does have platform-specific configuration.

Unix Requirements

Compiling Mindy for Unix requires the use of an ANSI C compiler. We highly recommend gcc (GNU CC) if it is available. d2c for Unix requires the gnu tools gmake, gcc, and gas. gdb is required for debugging. The gnu assembler (gas) must be used in conjunction with the generated code from gcc. If you somehow end up running the HP/UX "as" with gcc, it will produce many errors about STAB entries, etc. We actually have built d2c using non-Gnu ANSI C compilers and assemblers, as in the hppa-hpux-shared platform.

Windows Requirements

d2c for NT requires Microsoft Visual C++, the GNU assembler (gas), and several other Unix-ish utilities like rm, mv, and cmp. We use the Cygnus gnu-win32 distribution (this distribution includes the assembler.) It has an awful lot of problems, but we grudgingly admit that it's better than nothing. d2c is also believed to work with the gnu-win32 gcc, but we haven't built it that way recently.

Gwydion Dylan seems to work on Windows '95, but has not been extensively used on that platform.

Binary Installation

The binary distributions contain top-level bin, lib, etc and include directories. Ideally the distribution should be unpacked in /usr/local on Unix or c:\dylan on Windows. If the binaries are installed somewhere else, users must set the DYLANDIR environment variable to point to the root directory of the installation before they run d2c or Mindy.

You will also want to set your PATH environment variable to include the "bin/" directory so that you can actually run the installed programs. On Windows you may need to set other environment variables related to the C compiler.

.tar.gz files can be unpackaged by typing: 

        gzip -d filename.tar.gz
        tar -xvf filename.tar

.zip files (Windows only) can be unpackaged with any "unzip" utility that supports long file names. PKunzip is not one of these. A free unzip utility, the Info-ZIP extractor, is available in the release area.

Note about for unpacking the source distribution on Windows: There is a tar and gzip in the gnu-win32 distribution (see Windows Requirements), but tar seems rather flaky. You might want to try some commercial app such as WinZip. For help on using Gwydion Dylan, see the documentation index.

Build Instructions

To recompile Gwydion Dylan, you need Perl, which is used by the Makegen script. You will also need the binary distribution for your platform in order to get a working d2c.

Recompiling the entire system takes over an hour on 64meg 200mhz Pentium Pro running Windows/NT. This is almost all for the compilation of the d2c runtime and compiler; compiling just Mindy takes only a few minutes. d2c also uses lots of memory, especially when compiling itself: you want at least 48 meg, and more is better.

Build instructions have been divided into two pages:

[ Gwydion home page | mail to gwydion-group ]