anchor.diff:  
   This command will find the unprepped lib (and any others), and run the `compile` function using the `:build` alias, presumably filling the `target/classes` directory with necessary classes to put on the classpath (`"target/classes"` should be in the project `:paths`). More information on supporting unprepped dependencies is available in the https://clojure.org/reference/deps_and_cli#preparing-source-dependency-libs[Clojure CLI reference]. In the next section we'll talk about the new tools.build library which can be used to do that compilation when needed.
   
  -== Builds as programs
  +== Tools
   
  -The new tools.build library provides a set of task functions constructing programs in a deps.edn based project. The _“task functions”_ define a logically coherent portion of a build process. To learn more about the tasks supplied by tools.build you can read the https://clojure.github.io/tools.build[API] and https://clojure.org/guides/tools_build[guide].footnote:[You can also run the CLI command `clj -X:deps:build help/doc` if tools.build is a dependency in your deps.edn file under the `build` alias.]
  +You can also run the CLI command `clj -X:deps:build help/doc` if tools.build is a dependency in your deps.edn file under the `build` alias.
   
  -Build programs are Clojure source programs that use the tools.build task function API and provide build-specific _"target functions"_, suitable for execution via `clj -T`. In some cases it will also make sense to make composite target functions that combine a set of build targets. An example of using tools.build task functions to build up project-specific target functions in a build program is given in the https://clojure.org/guides/tools_build#source-library-jar-build[tools.build guide].
  -
  -While building aggregate targets by defining functions in your build.clj file is convenient, there are times when you may want to execute ad-hoc pipelines of task and target functions. To perform this, the Clojure CLI allows you to describe and execute a pipeline of functions on the command line, as shown below:
  -
  -```bash
  -clj -T:build clean jar <key/value pairs>
  -```
  -
  -The new `-T` execution mode for tools is similar to `-X` (execute a function) but automatically removes the project deps and paths, and adds `"."` to the `:paths`. It can also be invoked with a tool name (see the next section) in addition to with an alias.
  -
  -The key->value params are passed at the end and will be used to invoke the first function, `clean`, then the return of that will be passed to `jar`. How and whether you paramterize your project build is up to you. An example of this is also given in the guide.
  -
  -== Tools
   
   In addition to the support for builds, the Clojure CLI was enhanced with the ability to explore, install, invoke, and introspect tools based on a set of conventions for tool creators. Installing a new tool such as Sean Corfield's https://github.com/seancorfield/clj-new[clj-new] library is a simple as running the following command:
   
  
positive.code: 
  ifdef::env-github,env-browser[:outfilesuffix: .adoc]
  
  Clojure has evolved over the years and countless individuals and organizations have contributed to the growing success of its ecosystem. While there have been many build systems for Clojure, there has never been a build system available with the language. We have been laying the groundwork for this since the release of Clojure 1.9:
  
  - https://clojure.org/reference/deps_and_cli#_deps_edn[deps.edn] - a data structure for declaring dependencies
  - https://github.com/clojure/tools.deps.alpha/[tools.deps] - a library for building classpaths from deps.edn
  - https://clojure.org/reference/deps_and_cli[CLI] - a command line Clojure program runner
  
  Importantly, the facilities above embrace the idea of source-based libraries (as available from GitHub), in addition to the more common artifact-centric approach of the Java host ecosystem (which we continue to support as well).  With today's release we are pushing that idea further with more support for source-based libs (particularly on git), a new "batteries-included" story for Clojure builds called https://github.com/clojure/tools.build[tools.build], and more CLI support for https://clojure.org/reference/deps_and_cli#tool_install[tools].
  
  == Improving Source Libs
  
  Clojure’s dynamic nature allows us to rethink the way that libraries and applications are created to work directly with source code as our dependencies than requiring deployed artifacts. While the Clojure CLI has long supported git-based deps, it has been somewhat cumbersome to define a git-based dependency: there was no library name convention, the library name often repeated much of the url, there was no support for developer-named versions via tags, etc. While the previous format is still supported, the new format defines a convention for git libraries to infer the url, and the ability to specify meaningful versions via git tags. The short sha prefix is still included to verify the tag has not moved since definition:
  
  ```clojure
  {:deps {GIT-LIB {:git/tag "TAG" :git/sha "SHA"}
  
negative.code: 
  More information on the new https://clojure.org/reference/deps_and_cli#tool_install[tools support in the CLI] is available in the reference docs.
  
  == Installation
  
  A prerelease version of the CLI is now available: VERSION.
  
  On Mac or Linux, you can install the prerelease https://github.com/clojure/homebrew-tools#version-archive-tool-releases[using brew]. On Linux or Windows you can use the installer per the instructions in https://clojure.org/guides/getting_started[Getting Started] to install the specific version above.
  
  == What's Changed
  
  All items below are additive updates, there should be no changes required for existing deps.edn projects or CLI usage.
  
  * https://github.com/clojure/tools.build[tools.build] - a new library for builds
  ** https://clojure.github.io/tools.build[API]
  ** https://clojure.org/guides/tools_build[Guide]
  * deps.edn:
  *** If a git library name follows repo convention names, the `:git/url` can now be inferred (`:git/url` can still be specificed explicitly and takes precedence)
  *** `:git/tag` and short `:git/sha` can now be specified instead of the full sha. Both must point to the same commit.
  *** `:sha` has been renamed to `:git/sha` but the original is still supported for backwards compatibility
  *** A new `:deps/prep-lib` top-level key is used to publish how a lib can be prepared
  *** A new `: 
  * https://clojure.org/reference/deps_and_cli[Clojure CLI]
  * https://github.com/clojure/tools.deps.alpha[tools.deps.alpha]
  ** New API functions available via the built-in `:deps` alias
  ** New library API: `create-basis` (also available in tools.build - use that one if writing a build program)
  * https://github.com/clojure/tools.tools[tools.tools] - a tool library for managing tools
  ** https://clojure.github.io/tools.build[API]
  ** tools.tools is auto-installed by the Clojure CLI as a tool named `tools`
  
  Clojure now has a built-in story for source deps, builds, and tools including:
  
  - Source deps support - better git deps (https://clojure.org/reference/deps_and_cli#_git[reference]), support for source libs requiring prep (https://clojure.org/reference/deps_and_cli#prep[reference])
  - tools.build - a new library for writing build programs (https://clojure.github.io/tools.build[API], , https://github.com/clojure/tools.build[source])
  - -X support for running multiple functions at the CLI (https://clojure.org/reference/deps_and_cli#_executing_a_function[reference]) and passing trailing maps as arguments (https://clojure.org/reference/deps_and_cli##trailing-map-argument[reference])
  - Tool support - tool installation and use (https://clojure.org/reference/deps_and_cli#tool_install[reference]), better introspection (https://clojure.org/reference/deps_and_cli#other-programs[reference])
  
  
  
  You may also want to check out https://www.youtube.com/watch?v=BTAx-gFz6Ks[Alex Miller's talk] about this release at clojureD.
  
  Issues and bugs can be reported on https://ask.clojure.org or in Clojurians Slack in #tools-deps.
  