Another System Definition Facility, de facto standard build system for CL (mirrored from
Switch branches/tags
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
bin Fix regexps for version matching. Dec 8, 2016
contrib Rename stamp to timestamp in uiop/utility Oct 20, 2017
doc Documentation: update webpage, best_practices Dec 18, 2017
ext Update external build dependencies Mar 7, 2017
test Add a regression tests for upgrade Dec 5, 2017
tools install-asdf: avoid :back to please CMUCL Dec 6, 2017
uiop Bump version to Dec 18, 2017
.cl-source-registry.cache Add asdf-tools in the source-registry cache Jul 7, 2015
.gitattributes Don't export the ext/ subdir. Mar 23, 2016
.gitignore .gitignore core dumps Dec 12, 2017
.gitmodules ext: track the new git repo for closer-mop Feb 29, 2016
Makefile Don't force build/asdf.lisp Jul 21, 2017
Makefile-lisp-scripting Improve both Makefile's, notably show full version Mar 7, 2017 Small tweaks to README and best_practices Oct 8, 2017
TODO Update TODO Dec 12, 2017
action.lisp Fix more upgrade issues Jul 26, 2017
asdf.asd Bump version to Dec 18, 2017
backward-interface.lisp Add back make-build on ECL Jul 23, 2017
backward-internals.lisp Issue deprecation warnings only at 3.4, not at 3.3 Jul 20, 2017
bundle.lisp Fix upgrade issue with asdf/bundle. Dec 5, 2017
component.lisp Fix bug detecting need to reload defsystem. Jul 20, 2017
concatenate-source.lisp Fix upgrade issue with asdf/bundle. Dec 5, 2017
find-component.lisp Refactor load-asd to perform a define-op Jul 20, 2017
find-system.lisp Rename stamp to timestamp in uiop/utility Oct 20, 2017
footer.lisp Fix issues with ECL with the new plan Jul 21, 2017
forcing.lisp Separate forcing from plan Jul 20, 2017
header.lisp Bump version to Dec 18, 2017
interface.lisp Add back make-build on ECL Jul 23, 2017
lisp-action.lisp Fix more upgrade issues Jul 26, 2017
make-asdf.bat Separate forcing from plan Jul 20, 2017 Separate forcing from plan Jul 20, 2017
operate.lisp Deprecate require-system Jul 20, 2017
operation.lisp Disable check against operation initargs on Genera Sep 1, 2017
output-translations.lisp MKCL patch for upgrading. Dec 16, 2016
package-inferred-system.lisp Refactor load-asd to perform a define-op Jul 20, 2017
parse-defsystem.lisp Fix bug detecting need to reload defsystem. Jul 20, 2017
plan.lisp Merge branch 'stamp' into 'master' Oct 26, 2017
session.lisp plan: implement phase level escalation Jul 20, 2017
source-registry.lisp Fix more upgrade issues Jul 26, 2017
system-registry.lisp Replace *defined-systems* by *registered-systems* Jul 20, 2017
system.lisp Replace reset-system by reset-system-class Jul 20, 2017
upgrade.lisp Bump version to Dec 18, 2017
user.lisp Update "3.1.1" with "3.1.2" in documentation and comments. May 9, 2014
version.lisp-expr Bump version to Dec 18, 2017

ASDF: Another System Definition Facility

For general information about ASDF, consult the web page:

For some reference documentation, read the manual:

For a guide on how to use it, read our "best practices" document:

Below is a guide for ASDF developers. It is not meant for ASDF users.


Building ASDF

First, make sure ASDF is checked out under a path registered to the source-registry, if that isn't the case yet (see the manual). One place would be:


or, assuming your implementation provides ASDF 3.1 or later:


If you cloned our git repository rather than extracted a tarball, bootstrap a copy of build/asdf.lisp with:


Building the documentation

The manual is also in the doc/ subdirectory, and can be prepared with:

make -C doc

Testing ASDF

Before you may run tests, you need a few CL libraries. The simplest way to get them is as follows, but read below:

make ext

NOTA BENE: You may also need to run make ext again after you git pull or switch branch, to update the ext/ directory. This unhappily is not automatic. If for some reason tests fail, particularly due to an error compiling, loading or running a library, then run make ext and try again.

The above make target uses git submodule update --init to download all these libraries using git. If you don't otherwise maintain your own set of carefully controlled CL libraries, that's what you want to use. However, it is only available if you have a git checkout of ASDF; not if you used a tarball. If you use a tarball or otherwise do maintain your own set of carefully controlled CL libraries then you will want to use whichever tools you use (e.g. quicklisp, clbuild, or your own scripts around git) to download these libraries: alexandria, asdf-encodings, cl-launch, closer-mop, cl-ppcre, cl-scripting, fare-mop, fare-quasiquote, fare-utils, inferior-shell, lisp-invocation, named-readtables, optima.

If you are a CL developer, you may already have them, or may want to use your own tools to download a version of them you control. If you use Quicklisp, you may let Quicklisp download those you don't have. In these cases, you may NOT want to use the git submodules from make ext; you may undo a make ext with make noext. Otherwise, if you want to let ASDF download known-working versions of its dependencies, you can do it with make ext.

Once you have all the required libraries and the asdf-tools script can find a suitable Common Lisp implementation, you may run all the tests on a given Common Lisp implementation $L, with your favorite installed system $S, using:

make t u l=$L s=$S

To run only the regression test scripts, try simply:

make l=$L test-scripts

Lisp Scripting test system

ASDF by default uses a shell script in ./test/ to run the scripts that orchestrate its tests.

An alternate build and test system is available that uses Common Lisp as a scripting language. It is disabled by default because the new maintainer is having trouble with it in some of his environments. It worked fine for the previous maintainer in his environments, and may be particularly useful on Windows if and when the shell-based test system fails or is not available. Its source code is in tools/ and you can invoke it without going through GNU make, using the script, or, on Windows, make-asdf.bat.

To use this alternate test system, pass to make the extra arguments -f Makefile-lisp-scripting as in for instance:

make -f Makefile-lisp-scripting t l=sbcl

Or you can make that your local default (assuming GNU make) using:

echo "include Makefile-lisp-scripting" > GNUmakefile

These Lisp tools by default use Clozure Common Lisp (CCL) to build and run a binary build/asdf-tools that will orchestrate the tests. By defining and exporting the variable LISP to be one of ccl, sbcl or allegro, you can have it use an alternate Common Lisp implementation instead. Install CCL (respectively SBCL or Allegro) and make sure an executable called ccl (respectively sbcl or alisp) is in your PATH, or that you export a variable CCL (respectively SBCL or ALLEGRO) that points to the executable. To use a further Common Lisp implementation, suitably edit the script tools/asdf-tools, or, on Windows, the batch file tools/asdf-tools.bat. (Note that we recommend SBCL 1.3.13 or later when on Windows.)

Note that the executable build/asdf-tools is built the first time you test ASDF. When you update ASDF, via e.g. git pull or a branch switch, you may have to update it, with:

make -f Makefile-lisp-scripting build-asdf-tools

The reason this is not done automatically every time is because building it depends on a working ASDF; but when you're modifying ASDF and testing it, you cannot rely on a working ASDF: indeed, a developer may not only make mistakes, but may deliberately introduce or re-introduce bugs at some place to test code in another place.

Debugging ASDF

To interactively debug ASDF, you may load it in such a way that M-. will work, by installing the source code, and running:

(map () 'load (asdf:input-files :monolithic-concatenate-source-op "asdf"))

To interactively use the asdf-tools, you need to either have all its dependencies installed and configured. If you're using them through the ext/ directory and make ext, then you may need to emulate what the script in tools/asdf-tools does with respect to initializing the source-registry. Note that it also declares a system for cl-launch/dispatch; you can either do something similar, or expand the source for cl-launch with make -C ext/cl-launch source so cl-launch.asd will be created.

Using ASDF internals

If you have to use or extend internal functionality not currently exported by ASDF, please contact us and have us negociate a proper, stable, tested interface that you can actually rely on. Also, please DO NOT refer to specific subpackages such as asdf/find-system from the outside of ASDF, because functions may occasionally be moved from one internal package to the other, without notification. They have in the past and will in the future. Instead, when refering to symbols in ASDF, we recommend you either have your package :use the package :asdf or :import-from it, or that you shall use asdf: or asdf:: as a prefix to the symbols. And once again, please contact us if you have to use non-exported symbols.

Also, the normal way of extending ASDF is to use our class hierarchies for component and operation and to define methods on component-depends-on, perform, input-files, output-files. A common mistake seems to be that some people define methods on operate, which usually is not at all what they think it is.

How do I navigate this source tree?

  • asdf.asd

    • The system definition for building ASDF with ASDF.
  • *.lisp

    • The source code files for asdf/defsystem. See asdf.asd for the order in which they are loaded. All exported functions should have docstrings, and all internal functions should have comments. If any definition is insufficiently documented, please tell us: that's a bug.
  • uiop/

    • Utilities of Implementation- and OS- Portability, the portability layer of ASDF. It has its own README, and exported functions should all have docstrings and other ones comment, or once again it's a bug.
  • Makefile

    • The classical Makefile used for development purposes. Regular users only need to call make with the default target. Developers will typically use the like of make t l=sbcl or make u l=ccl.
  • bin/

    • bump-version -- a script to bump the version of ASDF, used by the classic Makefile. Use it with e.g. ./bin/bump-version 3.4.5 to test with the next version number before you release. NB: ASDF's version number notably affects the behavior of ASDF with respect to deprecated functions.
  • tools/

    • asdf-tools, a system to build, test and release ASDF. It includes:
      • asdf-tools -- a shell script to run it as a shell command.
      • asdf-tools.bat -- a Windows batch file to run the above.
      • asdf-tools.asd -- system definition for asdf-tools
      • *.lisp -- the source code for the asdf-tools system, except for the few files below. Check the .asd file for the order in which to read them.
    • Also a couple scripts to help ASDF users:
  • Makefile-lisp-scripting, and make-asdf.bat

    • Minimal Makefile and scripts to invoke the lisp scripting variants of the build system.
  • version.lisp-expr

    • The current version. Bumped up every time the code changes, using:

      make bump
  • doc/

  • test/

    • Regression test scripts (and ancillary files) for developers to check that they don't unintentionally break any of the functionality of ASDF. They are far from covering all of ASDF, but they are a good start.
      • script-support.lisp -- the common test infrastructure used by our tests
      • -- the shell script used by the classic Makefile to run tests. It is not used by the Lisp scripting variant of the Makefile.
  • contrib/

    • A few contributed files that show case how to use ASDF or help with debugging it or debugging programs that use it.
  • debian/

    • Files for packaging on Debian, Ubuntu, etc. (now only present in the debian branch).
  • build/

    • Where the Makefile and asdf-tools store their output files, including:
      • asdf.lisp -- the current one-file deliverable of ASDF
      • asdf-*.lisp -- for upgrade test purposes, old versions
      • asdf-tools -- the executable for asdf-tools (.exe on Windows)
      • results/ -- logs of tests that have been run
      • fasls/ -- output files while running tests
  • ext/

    • External dependencies, that can be populated with make ext or equivalently with git submodule update --init. Depopulate it with make noext or equivalently with: submodule deinit .

    • This file.
  • TODO

    • Plenty of ideas for how to further improve ASDF.