Dylan

Dylan is a multi-paradigm programming language that was created by Apple Computer in the early 1990s with the ambitious goal of combining the best features of dynamic languages like Lisp and Smalltalk with the performance characteristics needed for system programming. Its name stands for “DYnamic LANguage.”

History & Origins

The story of Dylan begins in the late 1980s at Apple’s Advanced Technology Group (ATG) in Cambridge, Massachusetts. The team set out to create a language that would bridge the gap between the flexibility and productivity of dynamic languages like Lisp and Smalltalk, and the raw performance of static languages like C++.

The Newton Connection

Dylan was originally intended to be the primary development language for the Apple Newton, one of the first personal digital assistants. The Newton project, led by Apple, represented an ambitious vision of mobile computing. Dylan was designed to provide:

• Dynamic flexibility for rapid development
• Efficient compilation for acceptable performance on limited hardware
• Object-oriented design for complex application architecture

However, Dylan’s implementation didn’t mature quickly enough for the Newton’s release timeline. The Newton ultimately shipped with a combination of C and NewtonScript, a language developed by Walter Smith specifically for the device.

Project Ralph

According to Apple Confidential by Owen W. Linzmayer, the Dylan project was originally codenamed “Ralph” after Ralph Ellison, the author of Invisible Man, reflecting its status as a secret research project within Apple.

The Language Design Team

The Dylan Language Specification of 1992 credits numerous contributors. Key figures included:

• Andrew Shalit - Led language design
• David Moon - Symbolics Lisp Machine architect, co-author of the Dylan Reference Manual
• Orca Starbuck - Co-author of the Dylan Reference Manual
• Glenn S. Burke, Robert Cassels, John Hotchkiss - Primary contributors to early language design

The same group at Apple that created Macintosh Common Lisp was responsible for Dylan, which explains the language’s strong Lisp heritage.

Syntax Evolution

One of Dylan’s most interesting features is its syntax evolution. The first Dylan Language Specification in 1992 used a Lisp-like syntax with parentheses and prefix notation:

1
2
3
4

(define-method factorial ((n <integer>))
  (if (< n 2)
      1
      (* n (factorial (- n 1)))))

However, the Dylan Reference Manual of 1994 introduced an ALGOL-like infix syntax that is still used today:

1
2
3
4
5
6
7

define method factorial (n :: <integer>) => (result :: <integer>)
  if (n < 2)
    1
  else
    n * factorial(n - 1)
  end
end method;

This syntax change was significant because it made Dylan more approachable to programmers from C, Pascal, and similar backgrounds, while retaining the language’s powerful dynamic and object-oriented capabilities.

Core Language Features

Multiple Dispatch

Like CLOS, Dylan uses multiple dispatch (also called multimethods), where the method to be called is determined by the types of all arguments, not just the first:

1
2
3
4
5
6
7

define method collide (a :: <asteroid>, b :: <spaceship>)
  // Handle asteroid hitting spaceship
end method;

define method collide (a :: <spaceship>, b :: <asteroid>)
  // Handle spaceship hitting asteroid
end method;

First-Class Everything

In Dylan, all values are first-class objects, including:

• Numbers and characters
• Functions and methods
• Classes and types

This uniformity comes directly from its Lisp heritage.

Dynamic Typing with Optional Type Declarations

Dylan is dynamically typed, but allows optional type declarations for documentation and optimization:

1
2
3
4
5

// No type declaration
define variable x = 42;

// With type declaration
define variable y :: <integer> = 42;

Macros

Dylan inherits powerful macro capabilities from Lisp, though with syntax adapted to its ALGOL-like appearance. Macros allow extending the language at compile time.

After Apple

Harlequin and CMU

When Apple abandoned Dylan development in 1995, the language didn’t die. Two groups continued its development:

Harlequin (later Functional Objects) created a commercial Dylan IDE for Microsoft Windows with advanced development tools. Their implementation was known for its integrated development environment and production-quality compiler.

Carnegie Mellon University developed Gwydion Dylan, an open-source implementation for Unix systems. The name “Gwydion” comes from Welsh mythology, referring to a magician figure.

Open Dylan

In 2004, the Functional Objects codebase was open-sourced and merged with Gwydion Dylan work to become Open Dylan, which remains actively developed today. The Open Dylan project has released regular updates:

• Open Dylan 2024.1 (February 2024)
• Open Dylan 2025.1 (June 2025)

Open Dylan provides:

• Command-line compiler for all major platforms
• Windows IDE (on Windows only)
• VS Code and Emacs integration
• Package manager (deft)

Language Philosophy

Dylan embodies several key design principles:

Performance Without Sacrificing Dynamism

Dylan was designed to prove that dynamic languages could be compiled to efficient native code. While full dynamism has some overhead, Dylan’s design allows programmers to add type information where performance matters, enabling aggressive optimization.

Object-Oriented from the Ground Up

Unlike languages that added object-orientation later, Dylan was designed as an object-oriented language from the start. Every value is an object, and the multiple dispatch system provides more flexibility than single-dispatch OOP.

Practical Lisp Heritage

Dylan takes the best ideas from Lisp—first-class functions, garbage collection, dynamic typing, macros—but packages them in a syntax more familiar to mainstream programmers.

Influence on Other Languages

While Dylan never achieved mainstream adoption, its ideas influenced other languages:

• Multiple dispatch concepts appear in Julia
• Goo was a Dylan-inspired language
• Lasso drew inspiration from Dylan’s design
• Some aspects of Dylan’s module system influenced later language designs

Why Dylan Still Matters

Dylan represents an interesting point in programming language history—an attempt to combine the productivity of dynamic languages with the performance needs of system programming. While it didn’t achieve widespread adoption, its design decisions and trade-offs remain instructive for language designers today.

The Open Dylan project keeps the language alive, and its combination of dynamic flexibility, powerful object system, and native code compilation provides a unique programming environment that some developers find highly productive.

Learning Dylan

Dylan has a moderate learning curve. The syntax is straightforward for programmers from C, Python, or similar backgrounds, but the multiple dispatch system and module/library organization take time to master.

Resources for learning Dylan include:

• The official Open Dylan documentation
• The Dylan Reference Manual
• The Open Dylan Tutorial and Introduction