diff --git a/asdf.asd b/asdf.asd
index caa550dbcf1bb0831cb3f6fde205ca5c0f26221d..81d13b907eae037aeb3bf5ed6d405777c737e027 100644
--- a/asdf.asd
+++ b/asdf.asd
@@ -74,7 +74,7 @@
   :licence "MIT"
   :description "Another System Definition Facility"
   :long-description "ASDF builds Common Lisp software organized into defined systems."
-  :version "2.32.9" ;; to be automatically updated by make bump-version
+  :version "2.32.10" ;; to be automatically updated by make bump-version
   :depends-on ()
   #+asdf3 :encoding #+asdf3 :utf-8
   ;; For most purposes, asdf itself specially counts as a builtin system.
diff --git a/backward-internals.lisp b/backward-internals.lisp
index cc3c6c37069bbb42ce3184ff96941e0e093c2a3f..c18713b829a85655b36f69036f24e30519195025 100644
--- a/backward-internals.lisp
+++ b/backward-internals.lisp
@@ -31,23 +31,18 @@
     (component-inline-methods component) nil)
 
   (defun %define-component-inline-methods (ret rest)
-    (dolist (name +asdf-methods+)
-      (let ((keyword (intern (symbol-name name) :keyword)))
-        (loop :for data = rest :then (cddr data)
-              :for key = (first data)
-              :for value = (second data)
-              :while data
-              :when (eq key keyword) :do
-                (destructuring-bind (op qual? &rest rest) value
-                  (multiple-value-bind (qual args-and-body)
-                      (if (symbolp qual?)
-                          (values (list qual?) rest)
-                          (values nil (cons qual? rest)))
-                    (destructuring-bind ((o c) &body body) args-and-body
-                      (pushnew
-                       (eval `(defmethod ,name ,@qual ((,o ,op) (,c (eql ,ret)))
-                                ,@body))
-                       (component-inline-methods ret)))))))))
+    (loop* :for (key value) :on rest :by #'cddr
+           :for name = (and (keywordp key) (find key +asdf-methods+ :test 'string=))
+           :when name :do
+           (destructuring-bind (op &rest body) value
+             (loop :for arg = (pop body)
+                   :while (atom arg)
+                   :collect arg :into qualifiers
+                   :finally
+                      (destructuring-bind (o c) arg
+                        (pushnew
+                         (eval `(defmethod ,name ,@qualifiers ((,o ,op) (,c (eql ,ret))) ,@body))
+                         (component-inline-methods ret)))))))
 
   (defun %refresh-component-inline-methods (component rest)
     ;; clear methods, then add the new ones
diff --git a/header.lisp b/header.lisp
index b7f183ffbdc7dcb2cdbc0e67126403b63ca74f62..b1d1a59963eb067291be9b36696303cd168016a6 100644
--- a/header.lisp
+++ b/header.lisp
@@ -1,5 +1,5 @@
 ;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp -*-
-;;; This is ASDF 2.32.9: Another System Definition Facility.
+;;; This is ASDF 2.32.10: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
 ;;; please mail to <asdf-devel@common-lisp.net>.
@@ -54,7 +54,7 @@
   (declaim (optimize (speed 1) (safety 3) (debug 3)))
   (setf ext:*gc-verbose* nil))
 
-#+(or abcl clisp clozure cmu ecl xcl)
+#+(or abcl clisp cmu ecl xcl)
 (eval-when (:load-toplevel :compile-toplevel :execute)
   (unless (member :asdf3 *features*)
     (let* ((existing-version
@@ -74,5 +74,5 @@
                                      (or #+abcl 2.25 #+cmu 2.018 2.27)))
         (rename-package :asdf away)
         (when *load-verbose*
-          (format t "; Renamed old ~A package away to ~A~%" :asdf away))))))
+          (format t "~&; Renamed old ~A package away to ~A~%" :asdf away))))))
 
diff --git a/operate.lisp b/operate.lisp
index 710b191e7ad06db49247df4765be1ce0a5cdd40f..004632adaebcfee41cdfe8caf785d6d4066fd89d 100644
--- a/operate.lisp
+++ b/operate.lisp
@@ -88,7 +88,7 @@ The :FORCE or :FORCE-NOT argument to OPERATE can be:
   (defmethod operate ((operation operation) (component component)
                       &rest keys &key &allow-other-keys)
     (let ((plan (apply 'traverse operation component keys)))
-      (perform-plan plan)
+      (apply 'perform-plan plan keys)
       (values operation plan)))
 
   (defun oos (operation component &rest args &key &allow-other-keys)
diff --git a/plan.lisp b/plan.lisp
index 9e060ff11048f22d5fd4efe88aed3c69c9fef5a4..ec217fbd65cf903b87aff08d5ab0aac78ad41c5a 100644
--- a/plan.lisp
+++ b/plan.lisp
@@ -386,9 +386,10 @@ processed in order by OPERATE."))
       (with-compilation-unit () ;; backward-compatibility.
         (call-next-method))))   ;; Going forward, see deferred-warning support in lisp-build.
 
-  (defmethod perform-plan ((steps list) &key)
-    (loop* :for (op . component) :in steps :do
-           (perform-with-restarts op component)))
+  (defmethod perform-plan ((steps list) &key force &allow-other-keys)
+    (loop* :for (o . c) :in steps
+           :when (or force (not (nth-value 1 (compute-action-stamp nil o c))))
+           :do (perform-with-restarts o c)))
 
   (defmethod plan-operates-on-p ((plan list) (component-path list))
     (find component-path (mapcar 'cdr plan)
diff --git a/test/test-compile-file-failure.script b/test/test-compile-file-failure.script
index a52a093b89f798f855935f17abe7023b12e3362b..7a14baf79fc303812891fa25de46cda771ab20c9 100644
--- a/test/test-compile-file-failure.script
+++ b/test/test-compile-file-failure.script
@@ -2,13 +2,14 @@
 
 (in-package :asdf)
 
-#-gcl2.6
+#+gcl2.6 (leave-test "GCL 2.6 sucks. Skipping test." 0)
+
 (assert (handler-case
             (let ((*compile-file-failure-behaviour* :warn))
               (load-system 'test-compile-file-failure :force t)
               t)
           (compile-file-error () nil)))
-#-gcl2.6
+
 (assert (handler-case
             (let ((*compile-file-failure-behaviour* :error))
               (load-system 'test-compile-file-failure :force t)
diff --git a/uiop/run-program.lisp b/uiop/run-program.lisp
index 97f6522b501db8fce96701078296e7106507b708..157991a39d366f761117b78f8404be45718398fa 100644
--- a/uiop/run-program.lisp
+++ b/uiop/run-program.lisp
@@ -354,7 +354,9 @@ Use ELEMENT-TYPE and EXTERNAL-FORMAT for the stream passed to the OUTPUT process
                (declare (ignorable interactive))
                #+(or abcl xcl) (ext:run-shell-command command)
                #+allegro
-               (excl:run-shell-command command :input interactive :output interactive :wait t)
+               (excl:run-shell-command
+                command :input interactive :output interactive :wait t
+                        #+os-windows :show-window #+os-windows (unless (or interactive (eq output t)) :hide))
                #+(or clisp clozure cmu (and lispworks os-unix) sbcl scl)
                (process-result (run-program command :pipe nil :interactive interactive) nil)
                #+ecl (ext:system command)
@@ -362,7 +364,7 @@ Use ELEMENT-TYPE and EXTERNAL-FORMAT for the stream passed to the OUTPUT process
                #+gcl (lisp:system command)
                #+(and lispworks os-windows)
                (system:call-system-showing-output
-                command :show-cmd interactive :prefix "" :output-stream nil)
+                command :show-cmd (or interactive (eq output t)) :prefix "" :output-stream nil)
                #+mcl (ccl::with-cstrs ((%command command)) (_system %command))
                #+mkcl (nth-value 2
                                  (mkcl:run-program #+windows command #+windows ()
diff --git a/uiop/uiop.asd b/uiop/uiop.asd
index 96f49b740f898ed58b2d871e0e104f5fa9210666..24ff669fecfceae548ea41d3403997d22c919ab6 100644
--- a/uiop/uiop.asd
+++ b/uiop/uiop.asd
@@ -17,7 +17,7 @@ UIOP is also known as ASDF/DRIVER or ASDF-UTILS,
 being transcluded into asdf.lisp together with ASDF/DEFSYSTEM."
   #+asdf3 :version #+asdf3 (:read-file-form "version.lisp-expr")
   #+asdf-encoding :encoding #+asdf-encoding :utf-8
-  :around-compile call-without-redefinition-warnings
+  #+asdf3 :around-compile #+asdf3 call-without-redefinition-warnings
   :components
   ((:static-file "version.lisp-expr")
    (:static-file "contrib/debug.lisp")
diff --git a/upgrade.lisp b/upgrade.lisp
index d455be97d12d7a4a36ef8ccd155e6553ee051443..a32f097b2bb40644a1b6a8a965829d758be84020 100644
--- a/upgrade.lisp
+++ b/upgrade.lisp
@@ -52,7 +52,7 @@ You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSIO
          ;; "3.4.5.67" would be a development version in the official upstream of 3.4.5.
          ;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5
          ;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67
-         (asdf-version "2.32.9")
+         (asdf-version "2.32.10")
          (existing-version (asdf-version)))
     (setf *asdf-version* asdf-version)
     (when (and existing-version (not (equal asdf-version existing-version)))
diff --git a/version.lisp-expr b/version.lisp-expr
index 72ec3c1c2ecda1410527d988f37ee2bfc690dbba..7aa2314be118d0a913e2a036fbc82c76f588d1e8 100644
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -1 +1 @@
-"2.32.9"
+"2.32.10"