Apple Dylan
ParadigmsMulti-paradigm: functional, object-oriented
DeveloperApple Computer
First appeared1992; 32 years ago (1992)
Stable release
Final / 1995; 29 years ago (1995)
Typing disciplineStrong, dynamic
Implementation languageMacintosh Common Lisp (MCL), Dylan
PlatformARM, IA-32
OSNewton OS, Classic Mac OS
Filename extensionsdylan
Major implementations
Apple Dylan
Influenced by
Macintosh Common Lisp, Smalltalk, Think C
Lasso, Python, Ruby

Apple Dylan is the original implementation of the programming language Dylan. It was developed by Apple Computer from 1992 to 1995.[1]

Dylan was developed at Apple Cambridge, formerly Coral Software, developers of Macintosh Common Lisp. The original language had much in common with Lisp, including its parenthetical S-expression syntax. For a time, it was developed with the intent of being the primary language of the Apple Newton. When that project was ordered into production earlier than expected, Dylan was not ready for release. A new operating system for the Newton was written in C++.

Dylan was then repositioned as a desktop programming system for the classic Mac OS. This led to a major change in syntax to a more C-like infix notation syntax, apparently at the prompting of a group at Carnegie Mellon University, to make it more appealing to programmers familiar with other languages. The resulting system was making progress when development was canceled in April 1995. Work continued for another six months to produce the Apple Dylan Technology Release. It was released at the 1996 WWDC show as the first and only official Apple version of the system.

Development environment

This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (June 2013) (Learn how and when to remove this template message)

Apple Dylan includes a dynamic, integrated development environment inspired by Smalltalk, Macintosh Common Lisp (MCL), and Think C, and originally codenamed Hula. Like Think C, but unlike Smalltalk and Lisp, it draws a clear distinction between the development environment and the program being developed. It does this by linking code, called a stub, into the target program, allowing the integrated development environment (IDE) to communicate with it (to inject code, perform introspection, etc.), without sharing a runtime system environment with the IDE.

The IDE includes Binder (a tool for configuring browsers), a source database, a definition database, incremental compiling, a cross-platform source debugger, profiling tools, and an interface builder.

The basic browser window in the Apple Dylan environment is Binder. A Binder window consists of one or more linked panes. Each pane has an input, an output, an aspect, and a presentation style. A pane's input is the output of another pane: a pane displays information about the selected object(s) in its input pane. Aspects are properties of the input, such as source code, contents, callers, readers, writers, references or compiling warnings. This information can be presented in an outline or a graph. Inputs, aspects and styles can be used to construct replicas of the Smalltalk source browser, or static call graphs, or ad hoc displays such as the callers of readers of variables that the selected function writes. All views are live: recompiling a function updates any displays that include its who-calls information, for example.

The outline view includes visual indicators that display whether a source record has unsaved changes, has changed since it was last compiled, or has compiler-generated messages (warnings and errors).

User interface framework

Apple Dylan includes a graphical user interface (GUI) framework,[2] written in Dylan by Mike Lockwood. The framework is tightly integrated with a WYSIWYG (What You See Is What You Get) interface builder code-named Meccano, written by Robin Mair. The interface builder is linked into an application, allowing users to switch between Edit and Run modes while the application is running. Decorators are represented as graphical objects that can be dragged onto a user interface object to modify its behavior or appearance via object composition.


The core of Apple Dylan is implemented in Macintosh Common Lisp, upon which the rest is implemented in Dylan. The Apple Cambridge office started as an acquisition of Coral Software, the developers of Macintosh Common Lisp.

When Dylan was retargeted from the ARM processor of the Newton, to the desktop Macintosh, the back end was modified to use APPLEX, a portable assembler designed by Wayne Loofbourrow's team at Apple in Cupertino.

See also


  1. ^ Dylan Hackers (2011–2019). "History". Open Dylan. Retrieved 2019-10-27.
  2. ^ Steele, Oliver. "Apple Dylan". Oliver Steele. Retrieved 2019-10-27.