Learn Dylan

A Quick Tour of Dylan

A quick overview of the language with examples of major features.

An Introduction to Dylan

This tutorial is written primarily for those with solid programming experience in C++ or another object-oriented, static language. It provides a gentler introduction to Dylan than does the Dylan Reference Manual (DRM).

Dylan Programming Guide

A book length Dylan tutorial.

Getting Started with the Open Dylan Command Line Tools

Describes development using the Open Dylan command line tools and editor integration (like emacs). This is mainly for Linux, FreeBSD, and macOS users.

Getting Started with the Open Dylan IDE

Describes Open Dylan’s integrated development environment (Windows only).

Building Applications With DUIM

Describes how to use DUIM (Dylan User Interface Manager), the portable window programming toolkit. (Windows only.)


Dylan Reference Manual (Errata)

The official definition of the Dylan language and standard library.

Dylan Library Reference

Reference docs for core libraries packaged with Open Dylan.

DUIM Reference

Describes the libraries forming DUIM (Dylan User Interface Manager), the portable window programming toolkit. It complements Building Applications Using DUIM. (Currently Windows only.)

Developing Component Software with CORBA

A tutorial and reference for CORBA interoperability using the Open Dylan ORB.


The Dylan Macro System by Dustin Voss.

This article holds hard-won knowledge about how the Dylan macro system works and how to work around some of the gotchas that may catch a macro writer.

Procedural Dylan by Paul Haahr.

This essay explores Dylan from the perspective of a programmer used to traditional procedural languages, such as Pascal or C.

Dylan Package Documentation

A quick introduction to web development in Dylan.

Development inside of Emacs using DIME by Hannes Mehnert.

An exciting look at using DIME and emacs for Dylan development. DIME is for Dylan what SLIME is for Common Lisp.

Beyond Java?

A discussion of some of the advantages Dylan provides over Java, based on Jason Trenouth’s experience writing a CORBA IDL compiler in both Java and Dylan. (Written around 2001 and Java now has better handling of numeric boxing/unboxing and, arguably, some other improvements.)


See the publications page for a full list. Below are a few highlighted publications.

LLVM Code Generation for Open Dylan (by Peter Housel at ELS 2020 pdf bib slides video)

The Open Dylan compiler, DFMC, was originally designed in the 1990s to compile Dylan language code targeting the 32-bit Intel x86 platform, or other platforms via portable C. As platforms have evolved since, this approach has been unable to provide efficient code generation for a broader range of target platforms, or to adequately support tools such as debuggers, profilers, and code coverage analyzers.

Developing a code generator for Open Dylan that uses the LLVM compiler infrastructure is enabling us to support these goals and modernize our implementation. This work describes the design decisions and engineering trade-offs that have influenced the implementation of the LLVM back-end and its associated run-time support.

Extending Dylan’s type system for better type inference and error detection (by Hannes Mehnert at ILC 2010 pdf bib)

Whereas dynamic typing enables rapid prototyping and easy experimentation, static typing provides early error detection and better compile time optimization. Gradual typing provides the best of both worlds. This paper shows how to define and implement gradual typing in Dylan, traditionally a dynamically typed language. Dylan poses several special challenges for gradual typing, such as multiple return values, variable-arity methods and generic functions (multiple dispatch).

In this paper Dylan is extended with function types and parametric polymorphism. We implemented the type system and a unification-based type inference algorithm in the mainstream Dylan compiler. As case study we use the Dylan standard library (roughly 32000 lines of code), which witnesses that the implementation generates faster code with fewer errors. Some previously undiscovered errors in the Dylan library were revealed.

D-Expressions: Lisp Power, Dylan Style [pdf] [bib]

This paper aims to demonstrate that it is possible for a language with a rich, conventional syntax to provide Lisp-style macro power and simplicity. We describe a macro system and syntax manipulation toolkit designed for the Dylan programming language that meets, and in some areas exceeds, this standard. The debt to Lisp is great, however, since although Dylan has a conventional algebraic syntax, the approach taken to describe and represent that syntax is distinctly Lisp-like in philosophy.

For Open Dylan Developers


Notes and materials useful to those working on Open Dylan itself or those who have an interest in the low level details.

Open Dylan Hacker’s Guide

A work in progress to help out people who are hacking on Open Dylan itself.

Dylan Style Guide

Notes and thoughts on how to format your Dylan code. This is the style guide that we aspire to adhere to in the Open Dylan sources.

Dylan Enhancement Proposals

A series of proposals for improvements to the Open Dylan implementation and related libraries.

Open Dylan Release Notes

Notes on new features and bug fixes in each release of Open Dylan.