This article was accepted into the corpus but its outbound wikilinks were never NER-processed — typical at the deepest BFS hop or when the run's entity cap was reached. No expansion funnel to show.
| ASDF (Another System Definition Facility) | |
|---|---|
| Name | ASDF |
| Title | Another System Definition Facility |
| Developer | Stefano Zacchiroli; contributors include Eli Barzilay, Tobias Rittweiler, Daniel Barlow, Mark Kantrowitz |
| Released | 2001 |
| Programming language | Common Lisp |
| Operating system | Linux, macOS, Microsoft Windows |
| Platform | x86, ARM |
| Genre | Software framework |
| License | MIT License |
ASDF (Another System Definition Facility) is a build system and system definition facility for Common Lisp designed to describe, compile, and load collections of Lisp source files and resources. It provides a declarative domain-specific language and runtime APIs to manage dependencies, build operations, and system descriptions across multiple Common Lisp implementations such as SBCL, CLISP, ECL, Allegro CL, and CCL (Common Lisp).
ASDF is a tool that sits between Common Lisp codebases and implementation-specific loaders, orchestrating actions like compiling, loading, and packaging for systems often called "systems" or "projects" in Lisp communities such as those around GNU Emacs, SLIME, Roswell (software), Quicklisp, and ULYSSES. It standardizes metadata, file layout, and dependency resolution so projects can interoperate across environments including Debian, Homebrew, and Windows Subsystem for Linux ecosystems familiar to developers from GitHub, GitLab, and Bitbucket.
ASDF originated as a successor to earlier Lisp tools such as defsystem implementations embedded in environments like CMUCL and Lucid Common Lisp, responding to portability needs raised by projects associated with Xach (Xach's projects), LispWorks, and contributors from GNU Project-adjacent communities. Over time, stewardship involved members of organizations and initiatives including European Lisp Symposium, Asia Lisp Conference, and maintainers active on infrastructures like SourceForge and GitHub. Development milestones intersect with the emergence of packaging efforts exemplified by Quicklisp and distribution changes tracked by communities around SBCL and CLiki.
ASDF models systems as entities with components, operations, and dependencies; its architecture borrows ideas from build tools used in contexts such as Make (software), Autotools, and Maven (software), while integrating Lisp-specific runtime integration like the one used by SLIME and Sly (software). Key concepts include system definition files (often using Common Lisp forms), component classes, and operation objects that implement actions like compile-op, load-op, and fasl-op; these are analogous to constructs found in Emacs Lisp packaging and module systems used by GNU Guix and Nix (package manager). ASDF's extensibility permits defining new operations and backends to adapt to toolchains used by ECL, Allegro CL, or deployment systems tied to Docker and Vagrant.
Users interact with ASDF using REPL-driven commands and programmatic APIs echoed in workflows from SLIME, Roswell (software), and Emacs. Common entry points include functions and macros that perform operations like asdf:load-system and asdf:operate; these are similar in intent to commands found in ecosystems such as Leiningen for Clojure or Bundler for Ruby. Typical command sequences integrate with version control workflows on GitHub or GitLab and continuous integration systems like Travis CI, GitHub Actions, and CircleCI for building and testing Lisp systems.
ASDF is implemented to run on multiple implementations including SBCL, CLISP, ECL, Allegro CL, Clozure CL, and ABCL. Integration points address implementation-specific FASL directories, compiler options, and startup hooks familiar from implementation documentation maintained by projects such as Steel Bank Common Lisp and communities around Clozure Common Lisp. Packaging and deployment via bridges like Quicklisp or distribution packages in Debian and Homebrew rely on ASDF metadata to locate and prepare systems across platforms like Linux, macOS, and Microsoft Windows.
ASDF is contrasted with historical defsystem flavors that were implementation-specific in projects maintained by CMUCL and Lucid Common Lisp; ASDF offers portability across implementations similarly to how Autotools aimed to abstract platform differences for GNU projects. Compared to Quicklisp, which functions as a distribution and dependency manager for Lisp libraries curated by Lisp community contributors like Zak Fisher, ASDF focuses on local system definition and build operations; Quicklisp often uses ASDF metadata to build and load packages. The relationship is analogous to differences between lower-level build systems such as Make (software) and higher-level package managers like apt (software) or Homebrew.
Common workflows begin with a system definition file placed in a project repository hosted on GitHub, GitLab, or Bitbucket; developers then invoke asdf:load-system to compile and load a system within SBCL or use tooling like Roswell (software) to script builds in CI services such as Travis CI or GitHub Actions. Example patterns include organizing sources into modules that mirror conventions from Emacs packages and using ASDF extensions to produce FASL caches for performance, akin to precompiled artefacts in Java environments managed by Maven (software) or Gradle. Packaging for distribution via Quicklisp or OS-level packaging systems involves mapping ASDF system definitions to release artifacts and metadata consumed by maintainers of Quicklisp and repository curators.