diff --git a/asdf.asd b/asdf.asd
index e9ba6846ce0f5653d5c52b9452aa7ca5f81fb84e..b531b25686dc8fe6742a37340b45ebaacb3b0884 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.8" ;; to be automatically updated by make bump-version
+  :version "2.32.11" ;; 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 497ff8de7e8b05b7a561e74796410e8e103650b7..9a892baaf7ae4ac920dabe014768d45e5515ce02 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.8: Another System Definition Facility.
+;;; This is ASDF 2.32.11: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
 ;;; please mail to <asdf-devel@common-lisp.net>.
@@ -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/run-tests.sh b/test/run-tests.sh
index 6d6410cfdf0cc83657a0abb1822d43a105cda32f..578125241974f41203fee715600e58a3fde6df9a 100755
--- a/test/run-tests.sh
+++ b/test/run-tests.sh
@@ -276,14 +276,13 @@ extract_tagged_asdf () {
         case $tag in
             1.*|2.0*|2.2[0-6]|2.26.61)
                 git show ${tag}:asdf.lisp > $file ;;
-            2.[2-9]*|3.*)
+            2.2[7-9]*|2.[3-9]*|3.*)
                 mkdir -p build/old/build
-                git archive ${tag} Makefile '*.lisp' 'uiop/*.lisp' | (cd build/old/ ; tar xf -)
+                git archive ${tag} | (cd build/old/ ; tar xf -)
                 make -C build/old
                 mv build/old/build/asdf.lisp build/asdf-${tag}.lisp
-                rm -rf build/old
-                ;;
-            *)
+                rm -rf build/old ;;
+             *)
                 echo "Don't know how to extract asdf.lisp for version $tag"
                 exit 55
                 ;;
@@ -328,6 +327,7 @@ valid_upgrade_test_p () {
 run_upgrade_tests () {
     cd ${ASDFDIR}
     mkdir -p  build/results
+    rm -f build/*.*f* ## Remove stale FASLs from ASDF 1.x, especially when different implementations have same name
     ASDF_OUTPUT_TRANSLATIONS="(:output-translations (\"${ASDFDIR}\" (\"${ASDFDIR}/build/fasls/\" :implementation \"asdf/\")) (t (\"${ASDFDIR}/build/fasls/\" :implementation \"root/\")) :ignore-inherited-configuration)"
     export ASDF_OUTPUT_TRANSLATIONS
     su=test/script-support.lisp
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/lisp-build.lisp b/uiop/lisp-build.lisp
index 04ccce09234d4987b69b9ec5196938a344edf277..9e04104a4a5c9530b4dcb9df892b69267ef15513 100644
--- a/uiop/lisp-build.lisp
+++ b/uiop/lisp-build.lisp
@@ -243,7 +243,7 @@ Note that ASDF ALWAYS raises an error if it fails to create an output file when
                       (list (unsymbolify-function-name fun)
                             (loop :for arg :in formals :collect
                                   (typecase arg ;; notably preserve constant keyword arguments
-                                    ((or symbol number character string pathname) arg)))
+                                    ((or symbol number character simple-string pathname) arg)))
                             nil)))))
     (defun unreify-deferred-warning (reified-deferred-warning)
       (destructuring-bind (&key warning-type function-name source-note args)
@@ -673,9 +673,9 @@ it will filter them appropriately."
                    :for n :from 1
                    :for f = (add-pathname-suffix
                              output (format nil "-FASL~D" n))
-                   :do #-lispworks-personal-edition (lispworks:copy-file i f)
-                   #+lispworks-personal-edition (concatenate-files (list i) f)
-                                                (push f fasls))
+                   :do ;; Not available on LW personal edition or LW 6.0 on Mac: (lispworks:copy-file i f)
+                   (concatenate-files (list i) f)
+                   (push f fasls))
              (ignore-errors (lispworks:delete-system :fasls-to-concatenate))
              (eval `(scm:defsystem :fasls-to-concatenate
                       (:default-pathname ,(pathname-directory-pathname output))
diff --git a/uiop/run-program.lisp b/uiop/run-program.lisp
index 93dcfe253d67c16561017c0bb598f8e792e53515..157991a39d366f761117b78f8404be45718398fa 100644
--- a/uiop/run-program.lisp
+++ b/uiop/run-program.lisp
@@ -264,7 +264,7 @@ Use ELEMENT-TYPE and EXTERNAL-FORMAT for the stream passed to the OUTPUT process
                           #+os-unix (coerce (cons (first command) command) 'vector)
                           #+os-windows command
                           :input interactive :output (or (and pipe :stream) interactive) :wait wait
-                          #+os-windows :show-window #+os-windows (and pipe :hide))
+                          #+os-windows :show-window #+os-windows (and (or (null output) pipe) :hide))
                          #+clisp
                          (flet ((run (f &rest args)
                                   (apply f `(,@args :input ,(when interactive :terminal) :wait ,wait :output
@@ -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 8813174f9c581dc07cbfa4aa52cfbaeccc80a2be..268e20c788c8bc8d49a2a8abbc28a896ef52aa27 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.8")
+         (asdf-version "2.32.11")
          (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 3c72c840f0fcc60ed573adbf85f71a62a9ec08fa..ea59c4012a229285779eb81a0a2b880fb259d1be 100644
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -1 +1 @@
-"2.32.8"
+"2.32.11"