diff --git a/.gitignore b/.gitignore
index e4da33ec1c935bb3c14d40ad5fed8238c5d10244..811f0304a917002af42150c13435e221d36d2770 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,3 +21,4 @@ lift-local.config
 *.fas 
 *.lib
 *.o
+*.*fsl
diff --git a/GNUmakefile b/GNUmakefile
index 03d202d00c63e8b658574651c39e4d47ae6db032..2043cf5d9319f12b1ea0f10f5bbf455e848f7f44 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -38,7 +38,7 @@ website-copy: FORCE
 	bin/rsync-cp.sh tmp/asdf.lisp $(webhome_private)
 
 clean_dirs = $(sourceDirectory)
-clean_extensions = fasl dfsl cfsl fasl fas lib dx32fsl
+clean_extensions = fasl dfsl cfsl fasl fas lib dx32fsl lx64fsl lx32fsl
 
 clean: FORCE
 	@for dir in $(clean_dirs); do \
diff --git a/README.source-registry b/README.source-registry
new file mode 100644
index 0000000000000000000000000000000000000000..a22fd664ab67fd04411a940388362998c6eb130a
--- /dev/null
+++ b/README.source-registry
@@ -0,0 +1,297 @@
+===========================
+Common Lisp Source Registry
+===========================
+
+This file specifies how build systems such as ASDF and XCVB
+may be configured with respect to filesystem paths
+where to search for Common Lisp source code.
+
+Configurations
+==============
+
+Configurations specify paths where to find system files.
+
+  1- An application may explicitly initialize the source-registry
+     configuration using the `Configuration API`_ below,
+     in which case this takes precedence.
+     It may itself compute this configuration from the command-line,
+     from a script, from its own configuration file, etc.
+
+  2- The source registry will be configured from
+     the environment variable ``CL_SOURCE_REGISTRY`` if it exists.
+
+  3- The source registry will be configured from
+     user configuration file
+	``~/.config/common-lisp/source-registry.conf``
+     if it exists.
+
+  4- The source registry will be configured from
+     user configuration directory
+	``~/.config/common-lisp/source-registry.conf.d/``
+     if it exists.
+
+  5- The source registry will be configured from
+     system configuration file
+	``/etc/common-lisp/source-registry.conf``
+     if it exists.
+
+  6- The source registry will be configured from
+     system configuration directory
+	``/etc/common-lisp/source-registry.conf.d/``
+     if it exists.
+
+  7- The source registry will be configured from a default configuration,
+     which allows for implementation-specific software to be searched.
+     (See below `Backward Compatibility`_).
+
+Each of these configuration is specified as a SEXP
+in a trival domain-specific language (defined below).
+Additionally, a more shell-friendly syntax is available
+for the environment variable (defined yet below).
+
+
+Backward Compatibility
+======================
+
+For backward compatibility, ASDF will fall back to its old ways
+of searching for ``.asd`` files in the directories specified in
+``asdf:*central-registry*``
+if it fails to find a configuration for the source registry, or
+if it fails to find a requested system in the configured source registry.
+This new mechanism will therefore not affect you if you don't use it,
+but will take precedence over the old mechanism if you do use it.
+
+Moreover, when using SBCL, now as before, ASDF will first look
+for a matching system in the implementation-specific ``contrib`` directory.
+This allows for some magic implementation-provided systems
+to be loaded specially in a version that matches your implementation.
+
+
+Configuration DSL
+=================
+
+Here is the grammar of the SEXP DSL for source-registry configuration:
+
+;; A configuration is single SEXP starting with keyword :source-registry
+;; followed by a list of directives.
+CONFIGURATION := (:source-registry DIRECTIVE ...)
+
+;; A directive is one of the following:
+DIRECTIVE :=
+    ;; add a single directory to be scanned (no recursion)
+    (:directory DIRECTORY-PATHNAME-DESIGNATOR) |
+
+    ;; add a directory hierarchy, recursing but excluding specified patterns
+    (:tree DIRECTORY-PATHNAME-DESIGNATOR) |
+
+    ;; override the default defaults for exclusion patterns
+    (:exclude PATTERN ...) |
+
+    ;; splice the parsed contents of another config file
+    (:include REGULAR-FILE-PATHNAME-DESIGNATOR) |
+
+    ;; Your configuration expression MUST contain
+    ;; exactly one of either of these:
+    (:inherit-configuration) | ; splices contents of inherited configuration
+    (:ignore-inherited-configuration) ; drop contents of inherited configuration
+
+    ;; This directive specifies that some default must be spliced.
+    (:default-registry)
+
+PATTERN := a string without wildcards, that will be matched exactly
+	against the name of a any subdirectory in the directory component
+        of a path. e.g. "_darcs" will match #p"/foo/bar/_darcs/src/bar.asd"
+
+
+Configuration Directories
+=========================
+
+Configuration directories consist in files each contains
+a list of directives without any enclosing ``(:source-registry ...)`` form.
+The files will be sorted by namestring as if by #'string< and
+the lists of directives of these files with be concatenated in order.
+An implicit ``:inherit-configuration`` will be included
+at the end of the list.
+
+This allows for packaging software with has file granularity
+(e.g. Debian's ``dpkg`` or some future version of ``clbuild``)
+to easily include configuration information about distributed software.
+
+Directories may be included by specifying a directory pathname
+or namestring in an ``:include`` directive, e.g.::
+	(:include "/foo/bar/")
+
+
+Shell-friendly syntax for configuration
+=======================================
+
+When considering environment variable ``CL_SOURCE_REGISTRY``
+ASDF will skip to next configuration if it's an empty string.
+It will ``READ`` the string as a SEXP in the DSL
+if it begins with a paren ``(``
+and it will be interpreted much like ``TEXINPUTS``
+as ``:`` (colon) separated list of paths, where
+
+  * each entry is a directory to add to the search path.
+
+  * if the entry ends with a double slash ``//``
+    then it instead indicates a tree in the subdirectories
+    of which to recurse.
+
+  * if the entry is the empty string (which may only appear once),
+    then it indicates that the inherited configuration should be
+    spliced there.
+
+
+Search Algorithm
+================
+
+In case that isn't clear, the semantics of the configuration is that
+when searching for a system of a given name,
+directives are processed in order.
+
+When looking in a directory, if the system is found, the search succeeds,
+otherwise it continues.
+
+When looking in a tree, if one system is found, the search succeeds.
+If multiple systems are found, the consequences are unspecified:
+the search may succeed with any of the found systems,
+or an error may be raised.
+ASDF currently returns the first system found,
+XCVB currently raised an error.
+If none is found, the search continues.
+
+Exclude statements specify patterns of subdirectories the systems of which
+to ignore. Typically you don't want to use copies of files kept by such
+version control systems as Darcs.
+
+Include statements cause the search to recurse with the path specifications
+from the file specified.
+
+An inherit-configuration statement cause the search to recurse with the path
+specifications from the next configuration
+(see section Configurations_ above).
+
+
+Caching Results
+===============
+
+The implementation is allowed to either eagerly compute the information
+from the configurations and file system, or to lazily re-compute it
+every time, or to cache any part of it as it goes.
+To explicitly flush any information cached by the system, use the API below.
+
+
+Configuration API
+=================
+
+The specified functions are exported from your build system's package.
+Thus for ASDF the corresponding functions are in package ASDF,
+and for XCVB the corresponding functions are in package XCVB.
+
+(initialize-source-registry)
+   will read the configuration and initialize all internal variables.
+
+(clear-source-registry)
+   undoes any source registry configuration
+   and clears any cache for the search algorithm.
+   You might want to call that before you
+   dump an image that would be resumed with a different configuration,
+   and return an empty configuration.
+   Note that this does not include clearing information about
+   systems defined in the current image, only about
+   where to look for systems not yet defined.
+
+(ensure-source-registry)
+   checks whether a source registry has been initialized.
+   If not, initialize it.
+   This function will be called before any attempt to find a system
+   in the source registry.
+   If your application wants to override the provided defaults,
+   it will have to use the below function process-source-registry.
+
+(process-source-registry X &key inherit collect)
+   If X is a CONS, parse it as a SEXP in the configuration DSL,
+   and extend or override inheritted configuration.
+   If X is a STRING, first parse it into a SEXP
+   as for the CL_SOURCE_REGISTRY
+   environment variable (see above) then process it.
+   If X is a PATHNAME, read the file as a single SEXP and process it.
+   The inheritted configuration is provided in keyword argument inherit,
+   itself a list of functions that take inherit
+   and collect keyword arguments
+   and defaulting to a list of functions
+   that implements the default behavior.
+
+
+Future
+======
+
+If this mechanism is successful, in the future, we may declare
+``asdf:*central-registry*`` obsolete and eventually remove it.
+Any hook into implementation-specific search mechanisms will by then
+have been integrated in the ``:default-configuration`` which everyone
+should either explicitly use or implicit inherit. Some shell syntax
+for it should probably be added somehow.
+
+But we're not there yet. For now, let's see how practical this new
+source-registry is.
+
+
+Rejected ideas
+==============
+
+Alternatives I considered and rejected included:
+
+1- Keep asdf:*central-registry* as the master with its current semantics,
+   and somehow the configuration parser expands the new configuration
+   language into a expanded series of directories of subdirectories to
+   lookup, pre-recursing through specified hierarchies. This is kludgy,
+   and leaves little space of future cleanups and extensions.
+
+2- Keep asdf:*central-registry* remains the master but extend its semantics
+   in completely new ways, so that new kinds of entries may be implemented
+   as a recursive search, etc. This seems somewhat backwards.
+
+3- Completely remove asdf:*central-registry*
+   and break backwards compatibility.
+   Hopefully this will happen in a few years after everyone migrate to
+   a better ASDF and/or to XCVB, but it would be very bad to do it now.
+
+4- Replace asdf:*central-registry* by a symbol-macro with appropriate magic
+   when you dereference it or setf it. Only the new variable with new
+   semantics is handled by the new search procedure.
+
+
+I've been suggested the below features, but have rejected them,
+for the sake of keeping ASDF no more complex than strictly necessary.
+
+* More syntactic sugar: synonyms for the configuration directives, such as
+  (:add-directory X) for (:directory X), or (:add-directory-hierarchy X)
+  or (:add-directory X :recurse t) for (:tree X).
+
+* The possibility to register individual files instead of directories.
+
+* Integrate Xach Beane's tilde expander into the parser,
+  or something similar that is shell-friendly or shell-compatible.
+  I'd rather keep ASDF minimal. But maybe this precisely keeps it
+  minimal by removing the need for evaluated entries that ASDF has?
+  i.e. uses of USER-HOMEDIR-PATHNAME and $SBCL_HOME
+  Hopefully, these are already superseded by the :default-registry
+
+* Using the shell-unfriendly syntax /** instead of // to specify recursion
+  down a filesystem tree in the environment variable.
+  It isn't that Lisp friendly either.
+
+
+Credits
+=======
+
+Thanks a lot to Stelian Ionescu for the initial idea.
+
+Thanks to Rommel Martinez for the initial implementation attempt.
+
+All bad design ideas and implementation bugs are to mine, not theirs.
+But so are good design ideas and elegant implementation tricks.
+
+ -- Francois-Rene Rideau <fare@tunes.org>, Sun, 24 Jan 2010 20:54:19 -0500
diff --git a/asdf.lisp b/asdf.lisp
index ad5b5225f1fd48d5935b866fa48ac71b6c559b82..990944e4efc440ecf8a6e6f6976e030c4ec72fcd 100644
--- a/asdf.lisp
+++ b/asdf.lisp
@@ -23,7 +23,7 @@
 ;;;  http://www.opensource.org/licenses/mit-license.html on or about
 ;;;  Monday; July 13, 2009)
 ;;;
-;;; Copyright (c) 2001-2009 Daniel Barlow and contributors
+;;; Copyright (c) 2001-2010 Daniel Barlow and contributors
 ;;;
 ;;; Permission is hereby granted, free of charge, to any person obtaining
 ;;; a copy of this software and associated documentation files (the
@@ -105,9 +105,10 @@
            #:*central-registry*         ; variables
            #:*compile-file-warnings-behaviour*
            #:*compile-file-failure-behaviour*
-           #:*asdf-revision*
            #:*resolve-symlinks*
 
+           #:asdf-version
+
            #:operation-error #:compile-failed #:compile-warned #:compile-error
            #:error-name
            #:error-pathname
@@ -137,8 +138,14 @@
            #:*map-all-source-files*
            #:output-files-for-system-and-operation
            #:*enable-asdf-binary-locations*
-           #:implementation-specific-directory-name)
+           #:implementation-specific-directory-name
+
+           #:initialize-source-registry
+           #:clear-source-registry
+           #:ensure-source-registry
+           #:process-source-registry)
   (:intern #:coerce-name
+           #:getenv
            #:system-registered-p
            #:asdf-message
            #:resolve-symlinks
@@ -149,6 +156,7 @@
   (:use #:common-lisp #:asdf)
   (:import-from #:asdf
                 #:coerce-name
+                #:getenv
                 #:system-registered-p
                 #:asdf-message
                 #:resolve-symlinks
@@ -164,9 +172,12 @@
 ;;;; -------------------------------------------------------------------------
 ;;;; User-visible parameters
 ;;;;
-(defparameter *asdf-revision*
+(defparameter *asdf-version*
   ;; the 1+ hair is to ensure that we don't do an inadvertent find and replace
-  (subseq "REVISION:1.375" (1+ (length "REVISION"))))
+  (subseq "VERSION:1.501" (1+ (length "VERSION"))))
+
+(defun asdf-version ()
+  *asdf-version*)
 
 (defvar *resolve-symlinks* t
   "Determine whether or not ASDF resolves symlinks when defining systems.
@@ -388,24 +399,72 @@ and NIL NAME and TYPE components"
          (values relative (butlast components) last-comp))))))
 
 (defun remove-keys (key-names args)
-  (loop for (name val) on args by #'cddr
-        unless (member (symbol-name name) key-names
-                       :key #'symbol-name :test 'equal)
-        append (list name val)))
-
-(defun remove-keyword (key arglist)
-  (labels ((aux (key arglist)
-             (cond ((null arglist) nil)
-                   ((eq key (car arglist)) (cddr arglist))
-                   (t (cons (car arglist) (cons (cadr arglist)
-                                                (remove-keyword
-                                                 key (cddr arglist))))))))
-    (aux key arglist)))
+  (loop :for (name val) :on args :by #'cddr
+    :unless (member (symbol-name name) key-names
+                    :key #'symbol-name :test 'equal)
+    :append (list name val)))
+
+(defun remove-keyword (key args)
+  (loop :for (k v) :on args :by #'cddr
+    :unless (eq k key)
+    :append (list k v)))
 
 (defun resolve-symlinks (path)
   #-allegro (truename path)
   #+allegro (excl:pathname-resolve-symbolic-links path))
 
+(defun getenv (x)
+  #+sbcl
+  (sb-ext:posix-getenv x)
+  #+clozure
+  (ccl::getenv x)
+  #+clisp
+  (ext:getenv x)
+  #+cmu
+  (cdr (assoc (intern x :keyword) ext:*environment-list*))
+  #+lispworks
+  (lispworks:environment-xiable x)
+  #+allegro
+  (sys:getenv x)
+  #+gcl
+  (system:getenv x)
+  #+ecl
+  (si:getenv x))
+
+(defun ensure-directory-pathname (pathspec)
+  "Converts the non-wild pathname designator PATHSPEC to directory form."
+  (cond
+   ((stringp pathspec)
+    (pathname (concatenate 'string pathspec "/")))
+   ((not (pathnamep pathspec))
+    (error "Invalid pathname designator ~S" pathspec))
+   ((wild-pathname-p pathspec)
+    (error "Can't reliably convert wild pathnames."))
+   ((directory-pathname-p pathspec)
+    pathspec)
+   (t
+    (make-pathname :directory (append (or (pathname-directory pathspec)
+                                          (list :relative))
+                                      (list (file-namestring pathspec)))
+                   :name nil :type nil :version nil
+                   :defaults pathspec))))
+
+(defun length=n-p (x n) ;is it that (= (length x) n) ?
+  (check-type n (integer 0 *))
+  (loop
+    :for l = x :then (cdr l)
+    :for i :downfrom n :do
+    (cond
+      ((zerop i) (return (null l)))
+      ((not (consp l)) (return nil)))))
+
+(defun ends-with (s suffix)
+  (check-type s string)
+  (check-type suffix string)
+  (let ((start (- (length s) (length suffix))))
+    (and (<= 0 start)
+         (string-equal s suffix :start1 start))))
+
 ;;;; -------------------------------------------------------------------------
 ;;;; Classes, Conditions
 
@@ -668,15 +727,6 @@ actually-existing directory."
     (and (check-one (pathname-name pathname))
          (check-one (pathname-type pathname)))))
 
-(defun ensure-directory-pathname (pathname)
-  (if (directory-pathname-p pathname)
-      pathname
-      (make-pathname :defaults pathname
-                     :directory (append
-                                 (pathname-directory pathname)
-                                 (list (file-namestring pathname)))
-                     :name nil :type nil :version nil)))
-
 (defun sysdef-central-registry-search (system)
   (let ((name (coerce-name system))
         (to-remove nil)
@@ -1049,26 +1099,26 @@ to `~a` which is not a directory.~@:>"
       (setf (visiting-component operation c) t)
       (unwind-protect
            (progn
-             (loop for (required-op . deps) in
-                  (component-depends-on operation c)
-                  do (do-dep required-op deps))
+             (loop :for (required-op . deps) :in
+               (component-depends-on operation c)
+               :do (do-dep required-op deps))
              ;; constituent bits
              (let ((module-ops
                     (when (typep c 'module)
                       (let ((at-least-one nil)
                             (forced nil)
                             (error nil))
-                        (loop for kid in (module-components c)
-                           do (handler-case
-                                  (appendf forced (traverse operation kid ))
-                                (missing-dependency (condition)
-                                  (if (eq (module-if-component-dep-fails c)
-                                          :fail)
-                                      (error condition))
-                                  (setf error condition))
-                                (:no-error (c)
-                                  (declare (ignore c))
-                                  (setf at-least-one t))))
+                        (dolist (kid (module-components c))
+                          (handler-case
+                              (appendf forced (traverse operation kid ))
+                            (missing-dependency (condition)
+                              (if (eq (module-if-component-dep-fails c)
+                                      :fail)
+                                  (error condition))
+                              (setf error condition))
+                            (:no-error (c)
+                              (declare (ignore c))
+                              (setf at-least-one t))))
                         (when (and (eq (module-if-component-dep-fails c)
                                        :try-next)
                                    (not at-least-one))
@@ -1086,8 +1136,8 @@ to `~a` which is not a directory.~@:>"
                                               :test #'string=)))))
                  (let ((do-first (cdr (assoc (class-name (class-of operation))
                                              (component-do-first c)))))
-                   (loop for (required-op . deps) in do-first
-                      do (do-dep required-op deps)))
+                   (loop :for (required-op . deps) :in do-first
+                     :do (do-dep required-op deps)))
                  (setf forced (append (delete 'pruned-op forced :key #'car)
                                       (delete 'pruned-op module-ops :key #'car)
                                       (list (cons operation c)))))))
@@ -1178,8 +1228,8 @@ to `~a` which is not a directory.~@:>"
 
 (defmethod perform around ((o load-op) (c cl-source-file))
   (let ((state :initial))
-    (loop until (or (eq state :success)
-                    (eq state :failure)) do
+    (loop :until (or (eq state :success)
+                     (eq state :failure)) :do
          (case state
            (:recompiled
             (setf state :failure)
@@ -1198,8 +1248,8 @@ to `~a` which is not a directory.~@:>"
 
 (defmethod perform around ((o compile-op) (c cl-source-file))
   (let ((state :initial))
-    (loop until (or (eq state :success)
-                    (eq state :failure)) do
+    (loop :until (or (eq state :success)
+                     (eq state :failure)) :do
          (case state
            (:recompiled
             (setf state :failure)
@@ -1296,26 +1346,26 @@ to `~a` which is not a directory.~@:>"
       (error 'missing-component-of-version :requires system :version version))
     (let ((steps (traverse op system)))
       (with-compilation-unit ()
-        (loop for (op . component) in steps do
-                 (loop
-                   (restart-case
-                       (progn (perform op component)
-                              (return))
-                     (retry ()
-                       :report
-                       (lambda (s)
-                         (format s "~@<Retry performing ~S on ~S.~@:>"
-                                 op component)))
-                     (accept ()
-                       :report
-                       (lambda (s)
-                         (format s "~@<Continue, treating ~S on ~S as ~
+        (loop :for (op . component) :in steps :do
+          (loop
+            (restart-case
+                (progn (perform op component)
+                       (return))
+              (retry ()
+                :report
+                (lambda (s)
+                  (format s "~@<Retry performing ~S on ~S.~@:>"
+                          op component)))
+              (accept ()
+                :report
+                (lambda (s)
+                  (format s "~@<Continue, treating ~S on ~S as ~
                                    having been successful.~@:>"
-                                 op component))
-                       (setf (gethash (type-of op)
-                                      (component-operation-times component))
-                             (get-universal-time))
-                       (return)))))))
+                          op component))
+                (setf (gethash (type-of op)
+                               (component-operation-times component))
+                      (get-universal-time))
+                (return)))))))
     op))
 
 (defun oos (operation-class system &rest args &key force (verbose t) version
@@ -1481,30 +1531,30 @@ Returns the new tree (which probably shares structure with the old one)"
                             type name in-order-to)))
 
 (defun %remove-component-inline-methods (component)
-  (loop for name in +asdf-methods+
-        do (map 'nil
-                ;; this is inefficient as most of the stored
-                ;; methods will not be for this particular gf n
-                ;; But this is hardly performance-critical
-                (lambda (m)
-                  (remove-method (symbol-function name) m))
-                (component-inline-methods component)))
+  (dolist (name +asdf-methods+)
+    (map ()
+         ;; this is inefficient as most of the stored
+         ;; methods will not be for this particular gf n
+         ;; But this is hardly performance-critical
+         (lambda (m)
+           (remove-method (symbol-function name) m))
+         (component-inline-methods component)))
   ;; clear methods, then add the new ones
   (setf (component-inline-methods component) nil))
 
 (defun %define-component-inline-methods (ret rest)
-  (loop for name in +asdf-methods+ do
-       (let ((keyword (intern (symbol-name name) :keyword)))
-	 (loop for data = rest then (cddr data)
-	      for key = (and data (first data))
-	      for value = (and data (second data)) 
-              while data
-	      when (eq key keyword) do
-	      (destructuring-bind (op qual (o c) &body body) value
-	      (pushnew
-		 (eval `(defmethod ,name ,qual ((,o ,op) (,c (eql ,ret)))
-				   ,@body))
-		 (component-inline-methods ret)))))))
+  (dolist (name +asdf-methods+)
+    (let ((keyword (intern (symbol-name name) :keyword)))
+      (loop :for data = rest :then (cddr data)
+        :for key = (when data (first data))
+        :for value = (when data (second data))
+        :while data
+        :when (eq key keyword) :do
+        (destructuring-bind (op qual (o c) &body body) value
+          (pushnew
+           (eval `(defmethod ,name ,qual ((,o ,op) (,c (eql ,ret)))
+                             ,@body))
+           (component-inline-methods ret)))))))
 
 (defun %refresh-component-inline-methods (component rest)
   (%remove-component-inline-methods component)
@@ -1559,23 +1609,22 @@ Returns the new tree (which probably shares structure with the old one)"
                        (module-default-component-class parent))))
         (let ((*serial-depends-on* nil))
           (setf (module-components ret)
-                (loop for c-form in components
-                      for c = (parse-component-form ret c-form)
-                      collect c
-                      if serial
-                      do (push (component-name c) *serial-depends-on*))))
+                (loop :for c-form :in components
+                  :for c = (parse-component-form ret c-form)
+                  :collect c
+                  :if serial
+                  :do (push (component-name c) *serial-depends-on*))))
 
         ;; check for duplicate names
         (let ((name-hash (make-hash-table :test #'equal)))
-          (loop for c in (module-components ret)
-                do
-                (if (gethash (component-name c)
-                             name-hash)
-                    (error 'duplicate-names
-                           :name (component-name c))
-                    (setf (gethash (component-name c)
-                                   name-hash)
-                          t)))))
+          (loop :for c in (module-components ret) :do
+            (if (gethash (component-name c)
+                         name-hash)
+                (error 'duplicate-names
+                       :name (component-name c))
+                (setf (gethash (component-name c)
+                               name-hash)
+                      t)))))
 
       (setf (component-in-order-to ret)
             (union-of-dependencies
@@ -1720,7 +1769,7 @@ See [implementation-specific-directory-name][] for details.")
   #-sbcl
   nil
   #+sbcl
-  (list (list (princ-to-string (sb-ext:posix-getenv "SBCL_HOME")) nil))
+  (list (list (princ-to-string (getenv "SBCL_HOME")) nil))
   "The \\*source-to-target-mappings\\* variable specifies mappings from source to target. If the target is nil, then it means to not map the source to anything. I.e., to leave it as is. This has the effect of turning off ASDF-Binary-Locations for the given source directory. Examples:
 
     ;; compile everything in .../src and below into .../cmucl
@@ -1810,8 +1859,8 @@ operating system, and hardware architecture."
                               (let ((feature (find subf *features*)))
                                 (when feature (return-from fp (first thing))))))))
                        (first-of (features)
-                         (loop for f in features
-                            when (fp f) return it))
+                         (loop :for f :in features
+                           :when (fp f) :return :it))
                        (maybe-warn (value fstring &rest args)
                          (cond (value)
                                (t (apply #'warn fstring args)
@@ -1848,12 +1897,11 @@ follow that.  For example, if SBCL is installed under a symlink, and
 SBCL_HOME is set through that symlink, the default rule above
 preventing SBCL contribs from being mapped elsewhere will not be
 applied by the plain `*source-to-target-mappings*`."
-  (loop for mapping in asdf:*source-to-target-mappings*
-        for (source target) = mapping
-        for true-source = (and source (resolve-symlinks source))
-        if (equal source true-source)
-          collect mapping
-        else append (list mapping (list true-source target))))
+  (loop :for mapping :in asdf:*source-to-target-mappings*
+    :for (source target) = mapping
+    :for true-source = (and source (resolve-symlinks source))
+    :if (equal source true-source) :collect mapping
+    :else :append (list mapping (list true-source target))))
 
 (defmethod output-files-for-system-and-operation
            ((system system) operation component source possible-paths)
@@ -1864,43 +1912,42 @@ applied by the plain `*source-to-target-mappings*`."
 (defmethod output-files-using-mappings (source possible-paths path-mappings)
   (mapcar
    (lambda (path)
-     (loop for (from to) in path-mappings
-        when (pathname-prefix-p from source)
-        do (return
-             (if to
-                 (merge-pathnames
-                  (make-pathname :type (pathname-type path))
-                  (merge-pathnames (enough-namestring source from)
-                                   to))
-                 path))
-
-        finally
-          (return
-            ;; Instead of just returning the path when we
-            ;; don't find a mapping, we stick stuff into
-            ;; the appropriate binary directory based on
-            ;; the implementation
-            (if *centralize-lisp-binaries*
-                (merge-pathnames
-                 (make-pathname
-                  :type (pathname-type path)
-                  :directory `(:relative
-                               ,@(cond ((eq *include-per-user-information* t)
-                                        (cdr (pathname-directory
-                                              (user-homedir-pathname))))
-                                       ((not (null *include-per-user-information*))
-                                        (list *include-per-user-information*)))
-                               ,@(implementation-specific-directory-name)
-                               ,@(rest (pathname-directory path)))
-                  :defaults path)
-                 *default-toplevel-directory*)
-                (make-pathname
-                 :type (pathname-type path)
-                 :directory (append
-                             (pathname-directory path)
-                             (implementation-specific-directory-name))
-                 :defaults path)))))
-          possible-paths))
+     (loop :for (from to) :in path-mappings
+       :when (pathname-prefix-p from source)
+       :return
+       (if to
+           (merge-pathnames
+            (make-pathname :type (pathname-type path))
+            (merge-pathnames (enough-namestring source from)
+                             to))
+           path)
+       :finally
+       (return
+         ;; Instead of just returning the path when we
+         ;; don't find a mapping, we stick stuff into
+         ;; the appropriate binary directory based on
+         ;; the implementation
+         (if *centralize-lisp-binaries*
+             (merge-pathnames
+              (make-pathname
+               :type (pathname-type path)
+               :directory `(:relative
+                            ,@(cond ((eq *include-per-user-information* t)
+                                     (cdr (pathname-directory
+                                           (user-homedir-pathname))))
+                                    ((not (null *include-per-user-information*))
+                                     (list *include-per-user-information*)))
+                            ,@(implementation-specific-directory-name)
+                            ,@(rest (pathname-directory path)))
+               :defaults path)
+              *default-toplevel-directory*)
+             (make-pathname
+              :type (pathname-type path)
+              :directory (append
+                          (pathname-directory path)
+                          (implementation-specific-directory-name))
+              :defaults path)))))
+   possible-paths))
 
 (defmethod output-files
     :around ((operation compile-op) (component source-file))
@@ -1926,18 +1973,14 @@ applied by the plain `*source-to-target-mappings*`."
 
 (defun read-null-terminated-string (s)
   (with-output-to-string (out)
-    (loop
-        for code = (read-byte s)
-        until (zerop code)
-        do (write-char (code-char code) out))))
+    (loop :for code = (read-byte s)
+      :until (zerop code)
+      :do (write-char (code-char code) out))))
 
 (defun read-little-endian (s &optional (bytes 4))
-  (let ((result 0))
-    (loop
-        for i from 0 below bytes
-        do
-          (setf result (logior result (ash (read-byte s) (* 8 i)))))
-    result))
+  (loop
+    :for i :from 0 :below bytes
+    :sum (ash (read-byte s) (* 8 i))))
 
 (defun parse-file-location-info (s)
   (let ((start (file-position s))
@@ -1993,6 +2036,280 @@ applied by the plain `*source-to-target-mappings*`."
       (end-of-file ()
         nil))))
 
+;;;; -----------------------------------------------------------------
+;;;; Source Registry Configuration, by Francois-Rene Rideau
+;;;; See README.source-registry and https://bugs.launchpad.net/asdf/+bug/485918
+
+(pushnew 'sysdef-source-registry-search *system-definition-search-functions*)
+
+;; Using ack 1.2 exclusions
+(defvar *default-exclusions*
+  '(".bzr" ".cdv" "~.dep" "~.dot" "~.nib" "~.plst"
+    ".git" ".hg" ".pc" ".svn" "CVS" "RCS" "SCCS" "_darcs"
+    "_sgbak" "autom4te.cache" "cover_db" "_build"))
+
+(defun default-registry ()
+  ())
+
+(defvar *source-registry* ()
+  "Either NIL (for uninitialized), or a list of one element,
+said element itself being a list of directory pathnames where to look for .asd files")
+
+(defun source-registry ()
+  (car *source-registry*))
+
+(defun (setf source-registry) (x)
+  (setf *source-registry* (list x)))
+
+(defun source-registry-initialized-p ()
+  (and *source-registry* t))
+
+(defun clear-source-registry ()
+  "Undoes any initialization of the source registry.
+You might want to call that before you dump an image that would be resumed
+with a different configuration, so the configuration would be re-read then."
+  (setf *source-registry* '())
+  (values))
+
+(defun sysdef-source-registry-search (system)
+  (ensure-source-registry)
+  (let ((name (coerce-name system)))
+    (block nil
+      (dolist (dir (source-registry))
+        (let ((defaults (eval dir)))
+          (when defaults
+            (cond ((directory-pathname-p defaults)
+                   (let ((file (and defaults
+                                    (make-pathname
+                                     :defaults defaults :version :newest
+                                     :name name :type "asd" :case :local)))
+                         #+(and (or win32 windows) (not :clisp))
+                         (shortcut (make-pathname
+                                    :defaults defaults :version :newest
+                                    :name name :type "asd.lnk" :case :local)))
+                     (when (and file (probe-file file))
+                       (return file))
+                     #+(and (or win32 windows) (not :clisp))
+                     (when (probe-file shortcut)
+                       (let ((target (parse-windows-shortcut shortcut)))
+                         (when target
+                           (return (pathname target))))))))))))))
+
+(defun read-file-forms (file)
+  (with-open-file (in file)
+    (loop :with eof = (list nil)
+     :for form = (read in nil eof)
+     :until (eq form eof)
+     :collect form)))
+
+(defun validate-source-registry-directive (directive)
+  (unless
+   (destructuring-bind (kw &rest rest) directive
+     (case kw
+       ((:include :directory :tree)
+        (and (length=n-p rest 1)
+             (typep (car rest) '(or pathname string))))
+       ((:exclude)
+        (every #'stringp rest))
+       ((:default-registry :inherit-configuration :ignore-inherited-configuration)
+        (null rest))))
+   (error "Invalid directive ~S~%" directive))
+  directive)
+
+(defun validate-source-registry-form (form)
+  (unless (and (consp form) (eq (car form) :source-registry))
+    (error "Error: Form is not a source registry ~S~%" form))
+  (loop :with inherit = 0
+        :for directive :in (cdr form) :do
+        (unless (consp directive)
+          (error "invalid directive ~S" directive))
+        (when (member (car directive)
+                      '(:inherit-configuration :ignore-inherited-configuration))
+          (incf inherit))
+        (validate-source-registry-directive directive)
+        :finally
+        (unless (= inherit 1)
+          (error "One and only one of :inherit-configuration or :ignore-inherited-configuration is required")))
+  form)
+
+(defun validate-source-registry-file (file)
+  (let ((forms (read-file-forms file)))
+    (unless (length=n-p forms 1)
+      (error "One and only one form allowed for source registry. Got: ~S~%" forms))
+    (validate-source-registry-form (car forms))))
+
+(defun validate-source-registry-directory (directory)
+  (let ((files (sort (ignore-errors
+                       (directory (merge-pathnames
+                                   (make-pathname :name :wild :type :wild)
+                                   directory)
+                                  #+sbcl :resolve-symlinks #+sbcl nil))
+                     #'string< :key #'namestring)))
+    `(:source-registry
+      ,@(loop :for file :in files :append
+          (mapcar #'validate-source-registry-directive (read-file-forms file)))
+      (:inherit-configuration))))
+
+(defun parse-source-registry-string (string)
+  (cond
+    ((or (null string) (equal string ""))
+     '(:source-registry (:inherit-configuration)))
+    ((not (stringp string))
+     (error "environment string isn't: ~S" string))
+    ((eql (char string 0) #\()
+     (validate-source-registry-form (read-from-string string)))
+    (t
+     (loop
+      :with inherit = nil
+      :with directives = ()
+      :with start = 0
+      :with end = (length string)
+      :for i = (or (position #\: string :start start) end) :do
+      (let ((s (subseq string start i)))
+        (cond
+         ((equal "" s) ; empty element: inherit
+          (when inherit
+            (error "only one inherited configuration allowed: ~S" string))
+          (setf inherit t)
+          (push '(:inherit-configuration) directives))
+         ((ends-with s "//")
+          (push `(:tree ,(subseq s 0 (1- (length s)))) directives))
+         (t
+          (push `(:directory ,s) directives)))
+         (setf start (1+ i))
+         (when (>= start end)
+           (unless inherit
+             (push '(:ignore-inherited-configuration) directives))
+           (return `(:source-registry ,@(nreverse directives)))))))))
+
+(defun collect-asd-subdirectories (directory &key (exclude *default-exclusions*) collect)
+  (let* ((files (ignore-errors
+                  (directory (merge-pathnames #P"**/*.asd" directory)
+                             #+sbcl #+sbcl :resolve-symlinks nil
+                             #+clisp #+clisp :circle t)))
+         (dirs (remove-duplicates (mapcar #'pathname-sans-name+type files) :test #'equal)))
+    (loop
+     :for dir :in dirs
+     :unless (loop :for x :in exclude
+                   :thereis (find x (pathname-directory dir) :test #'equal))
+     :do (funcall collect dir))))
+
+(defparameter *default-source-registries*
+  '(process-environment-source-registry
+    process-user-source-registry
+    process-system-source-registry
+    process-default-source-registry))
+
+(defun user-configuration-pathname ()
+  (merge-pathnames ".config/" (user-homedir-pathname)))
+(defun system-configuration-pathname ()
+  #p"/etc/")
+(defun source-registry-under (directory)
+  (merge-pathnames "common-lisp/source-registry.conf" directory))
+(defun user-source-registry-pathname ()
+  (source-registry-under (user-configuration-pathname)))
+(defun system-source-registry-pathname ()
+  (source-registry-under (system-configuration-pathname)))
+(defun source-registry-directory-under (directory)
+  (merge-pathnames "common-lisp/source-registry.conf.d/" directory))
+(defun user-source-registry-directory-pathname ()
+  (source-registry-directory-under (user-configuration-pathname)))
+(defun system-source-registry-directory-pathname ()
+  (source-registry-directory-under (system-configuration-pathname)))
+
+(defun process-environment-source-registry (&key inherit collect)
+  (process-source-registry (getenv "CL_SOURCE_REGISTRY")
+                           :inherit inherit :collect collect))
+(defun process-user-source-registry (&key inherit collect)
+  (process-source-registry (user-source-registry-pathname)
+                           :inherit inherit :collect collect))
+(defun process-system-source-registry (&key inherit collect)
+  (process-source-registry (system-source-registry-pathname)
+                           :inherit inherit :collect collect))
+(defun process-default-source-registry (&key inherit collect)
+  (declare (ignore inherit collect))
+  nil)
+
+(defgeneric process-source-registry (spec &key inherit collect))
+(defmethod process-source-registry ((pathname pathname) &key
+                                    (inherit *default-source-registries*)
+                                    collect)
+  (cond
+    ((directory-pathname-p pathname)
+     (process-source-registry (validate-source-registry-directory pathname)
+                              :inherit inherit :collect collect))
+    ((probe-file pathname)
+     (process-source-registry (validate-source-registry-file pathname)
+                              :inherit inherit :collect collect))
+    (t
+     (inherit-source-registry inherit :collect collect))))
+(defmethod process-source-registry ((string string) &key
+                                    (inherit *default-source-registries*)
+                                    collect)
+  (process-source-registry (parse-source-registry-string string)
+                           :inherit inherit :collect collect))
+(defmethod process-source-registry ((x null) &key
+                                    (inherit *default-source-registries*)
+                                    collect)
+  (inherit-source-registry inherit :collect collect))
+
+(defun make-collector ()
+  (let ((acc ()))
+    (values (lambda (x) (push x acc))
+            (lambda () (reverse acc)))))
+
+(defmethod process-source-registry ((form cons) &key
+                                    (inherit *default-source-registries*)
+                                    collect)
+  (multiple-value-bind (collect result)
+      (if collect
+          (values collect (constantly nil))
+        (make-collector))
+    (let ((*default-exclusions* *default-exclusions*))
+      (dolist (directive (cdr (validate-source-registry-form form)))
+        (process-source-registry-directive directive :inherit inherit :collect collect)))
+    (funcall result)))
+
+(defun inherit-source-registry (inherit &key collect)
+  (when inherit
+    (funcall (first inherit) :collect collect :inherit (rest inherit))))
+
+(defun process-source-registry-directive (directive &key inherit collect)
+  (destructuring-bind (kw &rest rest) directive
+    (ecase kw
+      ((:include)
+       (destructuring-bind (pathname) rest
+         (process-source-registry (pathname pathname) :inherit inherit :collect collect)))
+      ((:directory)
+       (destructuring-bind (pathname) rest
+         (funcall collect (ensure-directory-pathname pathname))))
+      ((:tree)
+       (destructuring-bind (pathname) rest
+         (collect-asd-subdirectories pathname :collect collect)))
+      ((:exclude)
+       (setf *default-exclusions* rest))
+      ((:default-registry)
+       (default-registry))
+      ((:inherit-configuration)
+       (inherit-source-registry inherit :collect collect))
+      ((:ignore-inherited-configuration)
+       nil))))
+
+;; Will read the configuration and initialize all internal variables,
+;; and return the new configuration.
+(defun initialize-source-registry ()
+  (setf (source-registry)
+        (inherit-source-registry *default-source-registries*)))
+
+;; checks an initial variable to see whether the state is initialized
+;; or cleared. In the former case, return current configuration; in
+;; the latter, initialize.  ASDF will call this function at the start
+;; of (asdf:find-system).
+(defun ensure-source-registry ()
+  (if (source-registry-initialized-p)
+      (source-registry)
+      (initialize-source-registry)))
+
 ;;;; -----------------------------------------------------------------
 ;;;; SBCL hook into REQUIRE
 ;;;;
@@ -2007,7 +2324,7 @@ applied by the plain `*source-to-target-mappings*`."
           t))))
 
   (defun contrib-sysdef-search (system)
-    (let ((home (sb-ext:posix-getenv "SBCL_HOME")))
+    (let ((home (getenv "SBCL_HOME")))
       (when (and home (not (string= home "")))
         (let* ((name (coerce-name system))
                (home (truename home))
@@ -2021,7 +2338,7 @@ applied by the plain `*source-to-target-mappings*`."
           (probe-file contrib)))))
 
   (pushnew
-   '(let ((home (sb-ext:posix-getenv "SBCL_HOME")))
+   '(let ((home (getenv "SBCL_HOME")))
       (when (and home (not (string= home "")))
         (merge-pathnames "site-systems/" (truename home))))
    *central-registry*)
@@ -2034,14 +2351,6 @@ applied by the plain `*source-to-target-mappings*`."
   (pushnew 'module-provide-asdf sb-ext:*module-provider-functions*)
   (pushnew 'contrib-sysdef-search *system-definition-search-functions*))
 
-;;;; -----------------------------------------------------------------
-;;;; TODO: Read Configuration.
-;;;; See https://bugs.launchpad.net/asdf/+bug/485918
-
-;;;; TODO: add protocols for re-searching a loaded system in the registry,
-;;;; for invalidating registry entries, etc.
-;;;; See https://bugs.launchpad.net/asdf/+bug/485687
-
 ;;;; -------------------------------------------------------------------------
 ;;;; Cleanups after hot-upgrade.
 ;;;; Things to do in case we're upgrading from a previous version of ASDF.
@@ -2057,9 +2366,10 @@ applied by the plain `*source-to-target-mappings*`."
 ;;;; -----------------------------------------------------------------
 ;;;; Done!
 (when *load-verbose*
-  (asdf-message ";; ASDF, revision ~a" *asdf-revision*))
+  (asdf-message ";; ASDF, version ~a" (asdf-version)))
 
 (pushnew :asdf *features*)
+;;(pushnew :asdf2 *features*) ;; do that when we reach version 2
 
 (provide :asdf)
 
diff --git a/bin/bump-revision-and-tag.sh b/bin/bump-revision-and-tag.sh
index d8e15fbf21e9f39382a156f43f0134eb55cb9728..40a9c41356b8777f18866bd3d88cd03072453b1d 100755
--- a/bin/bump-revision-and-tag.sh
+++ b/bin/bump-revision-and-tag.sh
@@ -35,7 +35,7 @@ fi
 new_version="$major.$bumped"
 
 cp asdf.lisp asdf.bak
-perl -pi -e "s/REVISION:[^\"]*\"/REVISION:$new_version\"/" asdf.lisp
+perl -pi -e "s/VERSION:[^\"]*\"/VERSION:$new_version\"/" asdf.lisp
 if [ ! "$?" == "0" ]; then
     echo "Unable to perl replace version"
     exit -3
diff --git a/debian/changelog b/debian/changelog
index de4d5779acb6d8df38f02fd6d9cce99e5fe2484e..f970541f80c5c4accf2f7a36f7eea25d57a65ac7 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,8 +1,8 @@
-cl-asdf (2:1.375-1~rc1) UNRELEASED; urgency=low
+cl-asdf (2:1.501-1~rc1) UNRELEASED; urgency=low
 
   * new upstream, back to version numbers.
 
- -- Peter Van Eynde <pvaneynd@debian.org>  Thu, 31 Dec 2009 10:13:47 +0100
+ -- Peter Van Eynde <pvaneynd@debian.org>  Wed, 27 Jan 2010 22:10:13 +0100
 
 cl-asdf (1:20091221-1) unstable; urgency=low
 
diff --git a/test/run-tests.sh b/test/run-tests.sh
index bff1c3cedc797b3a0129e193180a3d66cd3021c2..cb82c1eff4957fea5d15709112c943822e5ad90e 100755
--- a/test/run-tests.sh
+++ b/test/run-tests.sh
@@ -5,6 +5,7 @@
 # - quit with exit status 0 on getting eof
 # - quit with exit status >0 if an unhandled error occurs
 
+export CL_SOURCE_REGISTRY=$PWD
 
 if [ x"$1" = "xhelp" ]; then
     echo "$0 [lisp invocation] [scripts-regex]"
diff --git a/test/test-source-registry.s b/test/test-source-registry.s
new file mode 100644
index 0000000000000000000000000000000000000000..f82a69e839e88b275caa1c4cae84f8fae4bacc82
--- /dev/null
+++ b/test/test-source-registry.s
@@ -0,0 +1,121 @@
+(load "script-support")
+(load "../asdf")
+
+;; TODO:
+;; - test for conditions
+;; - use with-env for CL_SOURCE_REGISTRY
+;; - write clean-up procedures, if needed
+
+(eval-when (:execute :compile-toplevel :load-toplevel)
+  (require :sb-posix))
+
+(defpackage :test-source-registry
+  (:use #:cl #:asdf))
+
+(in-package :test-source-registry)
+
+(defun getenv (x)
+  #+sbcl
+  (sb-posix:getenv x))
+
+(defun setenv (x v)
+  #+sbcl
+  (sb-posix:putenv
+   (concatenate 'string x "=" v))
+  v)
+
+(defmacro with-gensyms ((&rest names) &body body)
+  `(let ,(loop for n in names collect `(,n (gensym)))
+     ,@body))
+
+(defmacro with-env ((&rest kv) &body body)
+  (let ((temps (loop :for i :upto (length kv) :collect (gensym)))
+        (keys (mapcar #'(lambda (x) (first x)) kv)))
+    (flet ((gen-getenvs ()
+             (mapcar #'(lambda (x y)
+                         `(,y (getenv ,x)))
+                     keys temps))
+           (gen-setenvs ()
+             (mapcar #'(lambda (x y) `(setenv ,y ,x))
+                     temps keys)))
+      `(let ,(gen-getenvs)
+         (unwind-protect
+              (progn
+                ,@(loop :for (k v) :in kv :collect `(setenv ,k ,v))
+                ,@body)
+           (progn ,@(gen-setenvs)))))))
+
+(defun make-temporary-directory ()
+  (let ((str (with-output-to-string (s)
+               (sb-ext:run-program "mktemp" '("-d" "-u") :search t :output s))))
+    (concatenate 'string
+                 (string-trim '(#\newline) str) "/")))
+
+(defvar *base-directory* (make-temporary-directory))
+
+(defun home-directory (&optional (base *base-directory*))
+  (let ((s (namestring (user-homedir-pathname))))
+    (merge-pathnames (subseq s 1 (length s)) base)))
+(defun system-directory (&optional (base *base-directory*))
+  (merge-pathnames "etc/" base))
+(defun tmp-directory (&optional (base *base-directory*))
+  (merge-pathnames "tmp/" base))
+
+(defun home-source-registry ()
+  (asdf::source-registry-under (merge-pathnames ".config/" (home-directory))))
+(defun system-source-registry ()
+  (asdf::source-registry-under (system-directory)))
+
+(defun merge-temp-under (path)
+  (namestring
+   (merge-pathnames
+    (let ((s (string-downcase
+              (prin1-to-string (gentemp)))))
+      (concatenate 'string s "/"))
+    path)))
+(defvar *asd-temp-path-1*
+  (merge-temp-under
+   (merge-temp-under (tmp-directory))))
+(defvar *system-source-registry-config*
+  `(:source-registry
+    (:inherit-configuration)
+    (:tree ,*asd-temp-path-1*)))
+(defvar *asd-temp-path-2*
+  (namestring (tmp-directory)))
+(defvar *home-source-registry-config*
+  `(:source-registry
+    (:inhert-configuration)
+    (:directory ,(namestring (tmp-directory)))))
+
+(defun write-registry-file (path contents)
+  (ensure-directories-exist path)
+  (with-open-file (out path
+                       :direction :output
+                       :if-exists :supersede)
+    (with-standard-io-syntax 
+      (format out "~S" contents))))
+(defun write-system-source-registry-config
+    (&key (path (system-source-registry)) (contents *system-source-registry-config*))
+  (write-registry-file path contents))
+(defun write-home-source-registry-config
+    (&key (path (home-source-registry)) (contents *home-source-registry-config*))
+  (write-registry-file path contents))
+
+;; use *asd-temp-path-X*?
+(defun create-asd-file (&optional (directory *default-pathname-defaults*))
+  (let ((*default-pathname-defaults* directory))
+    (with-open-file (out 
+  
+
+;; test environment variable
+(defun test-environment ()
+  (with-env-var (("CL_SOURCE_REGISTRY"
+                  (format nil "~A:~A" (home-directory) (system-directory))))
+    ...))
+
+;; test files
+(defun test-files ()
+  ...)
+
+;; (cl-user::quit-on-error
+;; ...)
\ No newline at end of file
diff --git a/website/source/contributors.md b/website/source/contributors.md
index f98276079fd0c20475211481f51bff355d86c40f..e3fb4d35350043a26760e03c70ad17be004250d3 100644
--- a/website/source/contributors.md
+++ b/website/source/contributors.md
@@ -1,14 +1,14 @@
-{include resources/header.md}
+{include "resources/header.md"}
 
 <div class="contents">
 
 ### Contributors
 
 * crhodes - Christophe Rhodes <csr21@cantab.net>
-* dan_b - Daniel Barlow 
+* dan_b - Daniel Barlow
 * demoss - Nikodemus Siivola <nikodemus@random-state.net>
 * gwking - Gary King <gwking@metabang.com>
-* kevinrosenberg - Kevin Rosenberg 
+* kevinrosenberg - Kevin Rosenberg
 * nhabedi - Edi Weitz
 * pvaneynd - Peter Van Eynde
 * rjain - Rahul Jain
@@ -19,7 +19,7 @@
 </div>
 
 </div>
-{include resources/footer.md}
+{include "resources/footer.md"}
 </div>
 
 
diff --git a/website/source/copyright.md b/website/source/copyright.md
index 02118518301d0d97862e918856d23866ca13ef0c..22decf5b7020319878fc6eb3ab087325fa2a3fca 100644
--- a/website/source/copyright.md
+++ b/website/source/copyright.md
@@ -1,10 +1,10 @@
-{include resources/header.md}
+{include "resources/header.md"}
 
 <div class="contents">
 
 ### Copyright
 
-ASDF Copyright (C) 2001-2009 Daniel Barlow and contributors 
+ASDF Copyright (C) 2001-2009 Daniel Barlow and contributors
 
 This website Copyright (C) 2001-2009 Daniel Barlow and
 contributors
@@ -34,7 +34,5 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 </div>
 
 </div>
-{include resources/footer.md}
+{include "resources/footer.md"}
 </div>
-
-
diff --git a/website/source/glossary.md b/website/source/glossary.md
index 1b10b8d17b8da7f923ddb19b64b84ff486097fb5..2e94f8e167a8e53b09e9ce146317273d0beeaa90 100644
--- a/website/source/glossary.md
+++ b/website/source/glossary.md
@@ -1,11 +1,11 @@
-{include resources/header.md}
+{include "resources/header.md"}
 
 ## Glossary
 
 {glossary}
 
- [fixture]> glossary The fixture is the environment in which a testcase runs. The 
-fixture is the code that prepares the environment for the test and that resets 
+ [fixture]> glossary The fixture is the environment in which a testcase runs. The
+fixture is the code that prepares the environment for the test and that resets
 the environment after the test. Fixtures can be shared by many test-cases.
 
-{include resources/footer.md}
+{include "resources/footer.md"}
diff --git a/website/source/manual.mmd b/website/source/manual.mmd
index 4ed2fd8b67211135be38c09f5efe863ca58ce027..58c49c59e2f80a902b4f4c77173df7a2091b9257 100644
--- a/website/source/manual.mmd
+++ b/website/source/manual.mmd
@@ -823,8 +823,6 @@ ASDF includes code to control where the binaries files are places. The location
 
 ## Special variables
 
-{docs *asdf-revision*}
-
 {docs *central-registry*}
 
 {docs *compile-file-warnings-behaviour*}
diff --git a/website/source/resources/header.md b/website/source/resources/header.md
index 059da795e236e163cced8d53a5394e49dae01ec3..0d4109545b923419cccb620358b83d4486caf248 100644
--- a/website/source/resources/header.md
+++ b/website/source/resources/header.md
@@ -1,4 +1,4 @@
-{include shared-header.md}
+{include "shared-header.md"}
 
 <div class="header">
 	<span class="logo">
diff --git a/website/source/resources/shared-header.md b/website/source/resources/shared-header.md
index 7e35df5a148fb5c1a7c6c8ee6761296d077e7aec..230dadd5db0b197f2b9a49e3391da2f4d926c953 100644
--- a/website/source/resources/shared-header.md
+++ b/website/source/resources/shared-header.md
@@ -1,4 +1,4 @@
-{include shared-links.md}
+{include "shared-links.md"}
 
 {set-property html yes}
 {set-property author "the ASDF group"}
@@ -17,19 +17,19 @@
  [tests]: test-results.html
  [git-browse]: http://common-lisp.net/gitweb?p=projects/asdf/asdf.git;a=summary
  [git-resources]: git.html
-  
+
  [asdf-devel]: http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-devel
  [asdf-announce]: http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-announce
 
  [asdf-home]: http://common-lisp.net/project/asdf/
  [asdf.lisp]: http://common-lisp.net/project/asdf/asdf.lisp
  [tarball]: http://common-lisp.net/project/asdf/asdf.tar.gz
- 
+
  [kmp-large]: http://www.nhplace.com/kent/Papers/Large-Systems.html
- 
+
  [hs-require]: http://www.lispworks.com/documentation/HyperSpec/Body/f_provid.htm#require
  [hs-standard-output]: http://www.lispworks.com/documentation/HyperSpec/Body/v_debug_.htm#STstandard-outputST
- 
- 
+
+
  [tinaa-project]: http://common-lisp.net/project/tinaa/
  [albert-project]: http://www.cliki.net/Albert/
\ No newline at end of file
diff --git a/website/source/resources/ug-header.md b/website/source/resources/ug-header.md
index 8b8b98dd4c46fcca91d6441de13a830b79bc86c0..667d2bf6bb5cd35b8670f9f704139422eba336d6 100644
--- a/website/source/resources/ug-header.md
+++ b/website/source/resources/ug-header.md
@@ -1,6 +1,6 @@
-{include shared-header.md}
+{include "shared-header.md"}
 
-{set-property style-sheets 
+{set-property style-sheets
   "user-guide.css"
   "http://common-lisp.net/project/cl-containers/shared/style-200.css"}