diff --git a/README.md b/README.md
index 86588690374d2d1a8c5233eae05850bf6548bf6b..a50fc77ec2afb0f4ea6212a9f1b48f3835dcea90 100644
--- a/README.md
+++ b/README.md
@@ -160,6 +160,27 @@ 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`.
+It is usually a very bad idea that doesn't usually do what you mean
+to define methods on `operate`.
+
+
 How do I navigate this source tree?
 -----------------------------------
 
@@ -176,7 +197,7 @@ How do I navigate this source tree?
       and functions all have docstrings.
 
 * [Makefile](Makefile)
-    * a minimal `Makefile` for bootstrap and development purposes.
+    * A minimal `Makefile` for bootstrap and development purposes.
       Most of the logic is in the [asdf-tools](tools/asdf-tools.asd) system below.
 
 * [tools/](tools/)
@@ -185,7 +206,7 @@ How do I navigate this source tree?
         * [asdf-tools.bat](tools/asdf-tools.bat) -- a Windows batch file to run the above.
         * [asdf-tools.asd](tools/asdf-tools.asd) -- system definition for asdf-tools
         * `*.lisp` -- the source code for the `asdf-tools` system, except for the few files below.
-    * also a couple scripts to help ASDF users:
+    * Also a couple scripts to help ASDF users:
         * [load-asdf.lisp](tools/load-asdf.lisp) -- a working example script to load, configure and use ASDF in a self-contained project
         * [install-asdf.lisp](install-asdf.lisp) -- replace and update an implementation's ASDF
         * [cl-source-registry-cache.lisp](cl-source-registry-cache.lisp) -- update a cache for the source-registry as a standalone script.
@@ -200,7 +221,7 @@ How do I navigate this source tree?
             make bump
 
 * [doc/](doc/)
-    * documentation for ASDF, including:
+    * Documentation for ASDF, including:
         * [index.html](doc/index.html) -- the web page for <http://common-lisp.net/project/asdf/>
         * [asdf.texinfo](doc/asdf.texinfo) -- our manual
         * [Makefile](doc/Makefile) -- how to build the manual
@@ -209,20 +230,20 @@ How do I navigate this source tree?
           -- auxiliaries of [index.html](doc/index.html)
 
 * [test/](test/)
-    * regression test scripts (and ancillary files) for developers to check
+    * Regression test scripts (and ancillary files) for developers to check
       that they don't unintentionally break any of the functionality of ASDF.
-      Far from covering all of ASDF, but a good start.
+      They are far from covering all of ASDF, but they are a good start.
 
 * [contrib/](contrib/)
-    * a few contributed files that show case how to use ASDF
+    * A few contributed files that show case how to use ASDF
       or help with debugging it or debugging programs that use it.
 
 * [debian/](debian/)
-    * files for packaging on Debian, Ubuntu, etc.
+    * Files for packaging on Debian, Ubuntu, etc.
       (now only present in the debian branch).
 
 * [build/](build/)
-    * where the `Makefile` and `asdf-tools` store their output files, including
+    * 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)
@@ -230,16 +251,13 @@ How do I navigate this source tree?
         * `fasls/` -- output files while running tests
 
 * [ext/](ext/)
-    * external dependencies, that can be populated with `make 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 .`
 
 * [README.md](README.md)
-    * this file.
+    * This file.
 
 * [TODO](TODO)
-    * plenty of ideas for how to further improve ASDF.
-
-
-Last updated Sunday, October 2nd, 2016.
+    * Plenty of ideas for how to further improve ASDF.
diff --git a/doc/asdf.texinfo b/doc/asdf.texinfo
index d9f446ee75b16321434885e68a26a82638f249ad..fac9f16c94c0838c7339ea0208e4e89a21116fc9 100644
--- a/doc/asdf.texinfo
+++ b/doc/asdf.texinfo
@@ -6238,7 +6238,8 @@ Also, bugs are currently tracked on launchpad:
   @url{http://xach.livejournal.com/}
 @item Francois-Rene Rideau and Robert Goldman:
   ``Evolving ASDF: More Cooperation, Less Coordination'', 2010.
-  This article describes the main issues solved by ASDF 2.
+  This article describes the main issues solved by ASDF 2,
+  and exposes its design principles.
   @url{https://common-lisp.net/project/asdf/doc/ilc2010draft.pdf}
   @url{https://gitlab.common-lisp.org/asdf/ilc2010}
 @item Francois-Rene Rideau and Spencer Brody:
diff --git a/doc/index.html b/doc/index.html
index d081331d733be08666cbe7f9eafa8c61d0c41ce6..0ce8f15279ff0cfc5c95fc6d059e549af6be45cc 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -568,6 +568,22 @@ Corman Common Lisp <admin@cormanlisp.com>
         <a id="news"></a>
         <h3>What is happening</h3>
         <dl>
+          <dt>December 2016</dt>
+          <dd>Release of 3.2.0, a release containing many notable improvements,
+            such as a new portable <tt>uiop:launch-program</tt> facility for
+            spawning asynchronous subprocesses
+            (with many thanks to Elias Pipping),
+            a <tt>uiop:with-deprecation</tt> facility to handle
+            progressive deprecation of functions,
+            a cleanup and tightening of the internal dependency model
+            (you are now required to use <tt>make-operation<tt>
+            to instantiate an operation class; also you'll be WARNed if your
+            <tt>.asd</tt> file contains improperly named secondary systems),
+            a systematic pass of adding documentation to all functions,
+            many fixes to small bugs and portability issues
+            across all underlying platforms and operating systems,
+            an improved test suite,
+            and the removal of some long deprecated functionality.</dd>
           <dt>March 2016</dt>
           <dd>Release of 3.1.7, another bug fix release for the 3.1.x series.</dd>
           <dt>October 2015</dt>
diff --git a/uiop/README.md b/uiop/README.md
index c0ec5bc1872b185ecb992ce43905f8c1b51348f1..77a9bbda592de4ea18ab1149f8a1e2e775958423 100644
--- a/uiop/README.md
+++ b/uiop/README.md
@@ -16,65 +16,86 @@ We recommend package `UIOP` be used to access all the symbols.
 
 The files that constitute UIOP are, in dependency loading order:
 
-* [package](package.lisp): deals with packages and their symbols, most notably including
-  `define-package`, a variant of `defpackage` capable of hot-upgrade, or
-  `symbol-call` and `find-symbol*` that are also useful for use in `.asd` files
-  before packages have been defined.
-
-* [common-lisp](common-lisp.lisp): lets you paper over various sub-standard implementations.
-  Big offenders are Corman, GCL, Genera, MCL, all of them unmaintained.
+* [package](package.lisp):
+  deals with packages and their symbols, most notably including
+  `define-package`, a variant of `defpackage` capable of hot-upgrade,
+  or `symbol-call` and `find-symbol*` that are also useful for use in `.asd`
+  files before packages have been defined.
+
+* [common-lisp](common-lisp.lisp):
+  lets you paper over various sub-standard implementations.
+  Big offenders are Corman, GCL, Genera, MCL, none of them regularly maintained.
   Supported without serious issues are:
   ABCL, Allegro, CCL, CMUCL, CLASP, CLISP, ECL, LispWorks, MKCL, SBCL, SCL, XCL.
 
-* [utility](utility.lisp): provides macros and functions that do not involve I/O; it handles
-  control-flow, (p)lists, characters, strings, functions, classes, conditions,
-  "stamps" (real number or boolean for +/- infinity), versions, etc.
+* [utility](utility.lisp):
+  provides macros and functions that do not involve I/O;
+  it handles control-flow, (p)lists, characters, strings, functions, classes,
+  conditions, "stamps" (real number or boolean for +/- infinity), etc.
   It also sports `uiop-debug`, a useful tool to help you debug programs.
 
-* [os](os.lisp): extracts information from your environment, including
-  an ABI identifier, features that distinguish Unix vs Windows,
+* [version](version.lisp):
+  manages ASDF-style versioning and a related `with-deprecation` facility
+  to gracefully declare that users should stop using some deprecated functions.
+
+* [os](os.lisp):
+  extracts information from your environment, including an ABI identifier,
+  features that distinguish Unix vs Windows,
   `getenv`, `hostname`, `getcwd` and `chdir`, etc.
 
-* [pathname](pathname.lisp): overcomes the gruesome non-portability trap that are CL pathnames
-  (and their lovecraftian "logical" variant), offering a vast array of
-  functions and a sensible, usable abstraction to specify relative pathnames.
+* [pathname](pathname.lisp):
+  overcomes the gruesome non-portability trap that are CL pathnames
+  (and their lovecraftian "logical" variant), offering a vast array of functions
+  and a sensible, usable abstraction to specify relative pathnames.
   It has a function `merge-pathnames*` to use instead of `merge-pathnames`, or
   even better, `subpathname` and its variant `subpathname*`; it has also plenty
   of functions for dealing with pathnames being directory vs file,
   physical vs logical, absolute vs relative, and more.
 
-* [filesystem](filesystem.lisp): provides portable access to the filesystem, inspecting it,
+* [filesystem](filesystem.lisp):
+  provides portable access to the filesystem, inspecting it,
   only using truename when desired, using native OS namestrings,
   atomic file renaming, creating or deleting directories, etc.
 
-* [stream](stream.lisp): portably deals with `*stderr*` vs `*error-output*`, character encodings
-  (external formats), element types, safe `read`ing and `write`ing, opening files
-  or temporary files, providing `format`-like designators for streams,
-  flushing output buffers, consuming or copying streams, concatenating streams
-  or files, copying files, etc.
+* [stream](stream.lisp):
+  portably deals with `*stderr*` vs `*error-output*`, character encodings
+  (external formats), element types, safe `read`ing and `write`ing,
+  opening files, using temporary files, flushing output buffers,
+  providing `format`-like designators for streams, consuming or copying streams,
+  concatenating streams or files, copying files, etc.
 
-* [image](image.lisp): portably deals with images, dumping them, restoring from them,
+* [image](image.lisp):
+  portably deals with images, dumping them, restoring from them,
   registering hooks to run at suitable events in the image lifetime,
   printing backtraces, handling fatal conditions, using or avoiding debug modes,
   accessing command line arguments or quitting the process.
 
-* [run-program](run-program.lisp): portably spawns external processes and captures their output.
-  Can also capture error-output, inject input, or let it all be interactive.
-
-* [lisp-build](lisp-build.lisp): portably compiles Common Lisp code, handles compilation results,
+* [lisp-build](lisp-build.lisp):
+  portably compiles Common Lisp code, handles compilation results,
   muffles uninteresting conditions, saves and restores deferred warnings,
   runs hooks around compilation (to e.g. control optimizations or syntax),
   identifies the pathname of the current file, combines FASLs, etc.
 
-* [configuration](configuration.lisp): portably locate and parse configuration files,
-  using best practices to define and validate syntax, search standard paths,
+* [launch-program](launch-program.lisp):
+  semi-portably launches a program as an asynchronous external subprocess.
+  Available functionality may depend on the underlying implementation.
+
+* [run-program](run-program.lisp):
+  fully portably runs a program as a synchronous external subprocess,
+  feed it input and capture its output.
+  Most implementations also allow interactive console subprocesses.
+
+* [configuration](configuration.lisp):
+  portably locates and parses configuration files, using best practices to
+  define and validate syntax, search standard paths,
   let users specify pathnames or pathname patterns, etc.
 
-* [backward-driver](backward-driver.lisp): provides backward-compatibility
-  with earlier incarnations of this library
+* [backward-driver](backward-driver.lisp):
+  provides backward-compatibility with earlier incarnations of this library
   (i.e. ASDF internals that have leaked, ASDF-UTILS, or older versions of UIOP).
 
-* [driver](driver.lisp): reexports all the above utilities in a single package `UIOP`.
+* [driver](driver.lisp):
+  reexports all the above utilities in a single package `UIOP`.
 
 
 Documentation
@@ -111,30 +132,41 @@ Using UIOP
 UIOP is part of ASDF 3, and any modern Common Lisp implementation
 will have all of UIOP available when you `(require "asdf")`.
 NB: `(require :asdf)` also works on all implementations but CLISP.
+Every implementation has sported ASDF 3 for years, and if yours only provides
+ASDF 2, we recommend you install ASDF 3 on top of it,
+using the facility in [tools/install-asdf.lisp](../tools/install-asdf.lisp).
+Every implementation has sported ASDF 3 for years, and if yours only provides
+ASDF 2, we recommend you install ASDF 3 on top of it,
+using the facility in [tools/install-asdf.lisp](../tools/install-asdf.lisp).
 
 If you need some functionality only available in a recent version of UIOP,
 but cannot or will not upgrade ASDF, UIOP is also distributed separately;
-see e.g. in Quicklisp. You may then have to load it like any other library:
+see e.g. in Quicklisp. You may then have to load it like any other library,
+by adding `"uiop"` or some versioned constraint `(:version "uiop" "3.2.0")`
+in your system's `:depends-on` declaration, or at the REPL using:
 
 	(asdf:load-system :uiop)
 
-If you want to use UIOP while preserving compatibility with ASDF 2,
-we recommend that in your ASDF system definition you may use the like of:
-
-	:depends-on (#-asdf3 :uiop)
+When refering to symbols in UIOP, we recommend you either have your package
+`:use` the package `:uiop` or `:import-from` it, or that you shall use `uiop:`
+as a prefix to the symbols. Please *DO NOT* refer to specific subpackages such as
+`uiop/run-program` from the outside of UIOP, 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.
 
 
 Some history
 ------------
 
-UIOP, formerly known as ASDF-DRIVER (the package and system nicknames live on),
-evolved from ASDF 2's internal utilities and portability layer.
+UIOP, formerly known as ASDF-DRIVER (the package and system nicknames are
+deprecated), evolved from ASDF 2's internal utilities and portability layer.
 It has since fully superseded functionality from the following libraries:
 ASDF-UTILS (UIOP carries on the ASDF 2 utilities that this exported),
-CL-FAD (UIOP's pathname and filesystem functions are much more portable),
+CL-FAD (UIOP completely replaces it with better design and implementation),
 CL-LAUNCH (UIOP took its image and command-line argument handling),
-EXTERNAL-PROGRAM, TRIVIAL-SHELL and XCVB-DRIVER (UIOP's run-program evolved
-from XCVB-DRIVER's, and so did its condition muffling),
+EXTERNAL-PROGRAM, TRIVIAL-SHELL and XCVB-DRIVER
+(UIOP's `run-program` and now `launch-program` evolved from XCVB-DRIVER,
+from which UIOP also initially got its condition muffling),
 SLIME's swank-loader (UIOP has better compilation and ABI identification),
 TRIVIAL-BACKTRACE (UIOP/IMAGE has all of it and more), etc.
 
diff --git a/uiop/build.xcvb b/uiop/build.xcvb
deleted file mode 100644
index 6965ec1d2d0372f0fd206979b4c2fef51151e5b5..0000000000000000000000000000000000000000
--- a/uiop/build.xcvb
+++ /dev/null
@@ -1,23 +0,0 @@
-#+xcvb
-(module
- (:fullname "/uiop"
-  :author ("Francois-Rene Rideau and contributors")
-  :licence "MIT" ;; MIT-style license. See asdf.lisp
-  :description "UIOP"
-  :long-description "Utilities for Implementation- and OS- Portability"
-  :supersedes-asdf ("uiop")
-  :build-image nil
-  :depends-on
-  ("package"
-   "common-lisp"
-   "utility"
-   "os"
-   "pathname"
-   "filesystem"
-   "stream"
-   "image"
-   "run-program"
-   "lisp-build"
-   "configuration"
-   "backward-driver"
-   "driver")))