{"id":32191253,"url":"https://github.com/tailrecursion/boot","last_synced_at":"2025-10-22T01:35:57.061Z","repository":{"id":9091847,"uuid":"10868985","full_name":"tailrecursion/boot","owner":"tailrecursion","description":"A Clojure build tool","archived":false,"fork":false,"pushed_at":"2014-12-31T22:46:37.000Z","size":2967,"stargazers_count":110,"open_issues_count":5,"forks_count":18,"subscribers_count":11,"default_branch":"master","last_synced_at":"2025-10-22T01:35:56.636Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"Clojure","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"epl-1.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/tailrecursion.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGES.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2013-06-22T17:01:23.000Z","updated_at":"2025-06-25T21:11:35.000Z","dependencies_parsed_at":"2022-08-29T03:00:38.658Z","dependency_job_id":null,"html_url":"https://github.com/tailrecursion/boot","commit_stats":null,"previous_names":[],"tags_count":14,"template":false,"template_full_name":null,"purl":"pkg:github/tailrecursion/boot","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tailrecursion%2Fboot","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tailrecursion%2Fboot/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tailrecursion%2Fboot/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tailrecursion%2Fboot/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/tailrecursion","download_url":"https://codeload.github.com/tailrecursion/boot/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tailrecursion%2Fboot/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":280365542,"owners_count":26318384,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-10-21T02:00:06.614Z","response_time":58,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2025-10-22T01:35:54.557Z","updated_at":"2025-10-22T01:35:57.051Z","avatar_url":"https://github.com/tailrecursion.png","language":"Clojure","funding_links":[],"categories":[],"sub_categories":[],"readme":"[![Stories in Ready](https://badge.waffle.io/tailrecursion/boot.png?label=ready\u0026title=Ready)](https://waffle.io/tailrecursion/boot)\n![arhimedes lever][1]\n\n# Boot\n\n\u003e Boot is moving to [boot-clj/boot](https://github.com/boot-clj/boot) starting\n\u003e with version 2.0.0. Version 1.x.x will remain in maintenance mode here.\n\nBoot is a shell interpreter for scripts written in Clojure. It is designed to be\nused with the “shebang” style of shell scripts to provide a simple means to have\nsingle file, self-contained scripts in Clojure that can include dependencies and\nso forth but don't need to be part of a project or uberjar. Also, boot is a\nClojure build tool.\n\n## Dependency\n\nArtifacts are published on Clojars.\n\n[![latest version][2]][3]\n\n## Overview\n\nBoot consists of two parts: the boot **loader** (this project), and the boot\n**core**.\n\n* **The boot loader is a Clojure program in executable uberjar format.** The\n  purpose of the loader is to add the boot core dependency to the classpath\n  (fetching it from Clojars if necessary) and then hand off execution to the\n  `-main` function defined there. The loader is designed to be as small, simple,\n  and stable as possible, because updating to a new version is relatively\n  awkward and it's important that scripts be runnable even if they were written\n  for an older version of the API.\n\n* **The boot core is a Maven dependency containing all of the actual boot\n  logic.** Since it's loaded into the loader dynamically it can be updated\n  easily, without requiring changes to the loader. The core version is specified\n  in the script file to provide repeatability–scripts pull in everything they\n  need to run, including the boot core itself. In addition to the machinery for\n  interpreting Clojure scripts, the core also contains a number of features\n  specific to boot's other role as a build tool for Clojure projects.\n\n### Clojure Scripts\n\nBoot scripts have three parts: the **shebang**, the **core version declaration**,\nand a number of (optional) **top level forms**.\n\nThe shebang tells your shell to use the boot loader to interpret the script:\n\n```clojure\n#!/usr/bin/env boot\n```\n\nThe core version declaration tells the boot loader which version of the boot\ncore to use:\n\n```clojure\n#tailrecursion.boot.core/version \"2.5.0\"\n```\n\nAny remaining forms in the script file are evaluated in the boot environment:\n\n```clojure\n(set-env! :dependencies '[[riddley \"0.3.4\"]])\n(require '[clojure.string :refer [join]])\n\n(defn -main [\u0026 args]\n  (println (join \" \" [\"hello,\" \"world!\"]))\n  (System/exit 0))\n```\n\n## Getting Started\n\nThe easiest way to get started is to download the prebuilt Jar file. It's built\nto be executable in a Unix environment. In Windows you'll have to use it via\n`java -jar ...` unless you have Cygwin installed (I think).\n\n### Windows\n\n* [Download the boot Jar file.][8]\n* Use boot by doing `java -jar boot-1.1.1.jar ...`.\n\n### Unix\n\n```\n$ wget https://clojars.org/repo/tailrecursion/boot/1.1.1/boot-1.1.1.jar\n$ mv boot-1.1.1.jar boot\n$ chmod a+x boot\n$ mv boot ~/bin/boot # or anywhere else in your $PATH\n```\n\n### Build From Source\n\nTo build boot from source you will need:\n\n* Java 1.6+\n* [Leiningen][4] 2\n* GNU Make\n\nBuild and install boot:\n\n```\n$ git clone https://github.com/tailrecursion/boot.git\n$ cd boot\n$ make boot\n$ mv ./boot ~/bin/boot # or anywhere else in your $PATH\n```\n\n### Hello World\n\nA simple example to get started:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n\n(defn -main [\u0026 args]\n  (println \"hello, world!\")\n  (System/exit 0))\n```\n\nWrite that to a file, say `build.boot`, set execute permissions on the file, and\nrun it in the terminal to enjoy a friendly greeting.\n\n\u003e Note: scripts interpreted by boot must have the `.boot` file extension.\n\n### Script Dependencies\n\nScripts can add Maven repositories and/or dependencies at runtime using\n`set-env!`:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n\n(set-env!\n  :repositories #{\"http://me.com/maven-repo\"}\n  :dependencies '[[com.hello/foo \"0.1.0\"]])\n\n(require '[com.hello.foo :as foo])\n\n(defn -main [\u0026 args]\n  (println (foo/do-stuff args))\n  (System/exit 0))\n```\n\n## Boot Build Tool\n\nIn addition to interpreting scripts, boot also provides some facilities to help\nbuild Clojure projects. Omitting the `-main` function definition puts boot into\nbuild tool mode.\n\n### A Minimal Build Script\n\nCreate a minimal `build.boot` file containing only the shebang and core version:\n\n```\n$ boot :strap \u003e build.boot\n```\n\nThe resulting file should contain something like this:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n```\n\nThen run it. You should see version and usage info and a list of available\ntasks:\n\n```\n$ boot\ntailrecursion/boot 1.0.0: http://github.com/tailrecursion/boot\n\nUsage: boot OPTS task ...\n       boot OPTS [task arg arg] ...\n       boot OPTS [help task]\n\nOPTS:  :v       Verbose exceptions (full cause trace).\n       [:v n]   Cause trace limited to `n` elements each.\n\nTasks: debug      Print the value of a boot environment key.\n       help       Print help and usage info for a task.\n       lein       Run a leiningen task with a generated `project.clj`.\n       repl       Launch nrepl in the project.\n       syncdir    Copy/sync files between directories.\n       watch      Watch `:src-paths` and call its continuation when files change.\n\nCreate a minimal boot script: `boot :strap \u003e build.boot`\n\n```\n\nThe tasks listed in the output are defined in the [core tasks namespace][5],\nwhich is referred into the script namespace automatically. Any tasks defined or\nreferred into the script namespace will be displayed in the list of available\ntasks printed by the default `help` task.\n\n\u003e Notice that when the boot script file is named `build.boot` and located is in\n\u003e the current directory you can call `boot` directly instead of executing the\n\u003e boot script file itself. This is more familiar to users of Leiningen or GNU\n\u003e Make, for example, and reinforces build repeatability by standardizing the\n\u003e build script filename and location in the project directory.\n\n### A Simple Task\n\nLet's create a task to print a friendly greeting to the terminal. Modify the\n`build.boot` file to contain the following:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n\n(deftask hello\n  \"Print a friendly greeting.\"\n  [\u0026 [name]]\n  (fn [continue]\n    (fn [event]\n      (printf \"hello, %s!\\n\" (or name \"world\"))\n      (continue event))))\n```\n\nRun it again to see the new task listed among the other available tasks:\n\n```\n$ boot\ntailrecursion/boot 1.0.0: http://github.com/tailrecursion/boot\n\nUsage: boot OPTS task ...\n       boot OPTS [task arg arg] ...\n       boot OPTS [help task]\n\nOPTS:  :v       Verbose exceptions (full cause trace).\n       [:v n]   Cause trace limited to `n` elements each.\n\nTasks: debug      Print the value of a boot environment key.\n       hello      Print a friendly greeting.\n       help       Print help and usage info for a task.\n       lein       Run a leiningen task with a generated `project.clj`.\n       repl       Launch nrepl in the project.\n       syncdir    Copy/sync files between directories.\n       watch      Watch `:src-paths` and call its continuation when files change.\n\nCreate a minimal boot script: `boot :strap \u003e build.boot`\n\n```\n\nNow we can run the `hello` task:\n\n```\n$ boot hello\nhello, world!\n```\n\n### Command Line Arguments To Tasks\n\nAn argument can be passed to the `hello` task like this:\n\n```\n$ boot \\(hello :foo\\)\nhello, :foo!\n```\n\nThe command line is read as Clojure forms, but task expressions can be enclosed\nin square brackets (optionally) to avoid having to escape parens in the shell,\nlike this:\n\n```\n$ boot [hello :foo]\nhello, :foo!\n```\n\n### Command Line Composition Of Tasks\n\nTasks can be composed on the command line by specifying them one after the other,\nlike this:\n\n```\n$ boot [hello :foo] [hello :bar]\nhello, :foo!\nhello, :bar!\n```\n\nBecause tasks return middleware functions they can be composed uniformly, and\nthe product of the composition of two task middleware functions is itself a\ntask middleware function. The two instances of the `hello` task above are being\ncombined by boot something like this:\n\n```clojure\n;; [\u0026 args] command line argument list\n(\"[hello\" \":foo]\" \"[hello\" \":bar]\")\n  ;; string/join with \" \" and read-string\n  =\u003e ([hello :foo] [hello :bar])\n  ;; convert top-level vectors to lists\n  =\u003e ((hello :foo) (hello :bar))\n  ;; compose with comp when more than one\n  =\u003e (comp (hello :foo) (hello :bar))\n```\n\nThis yields a middleware function that is called by boot to actually perform\nthe build process. The composition of middleware sets up the pipeline of tasks\nthat will participate in the build. The actual handler at the bottom of the\nmiddleware stack is provided by boot–it syncs artifacts between temporary\nstaging directories (more on these later) and output/target directories.\n\n### Create New Task By Composition\n\nHere we create a new named task in the project boot script by composing other\ntasks. This is a quick way to fix options and simplify documenting the build\nprocedures. Tasks are functions that return middleware, and middleware are\nfunctions that can be composed uniformly, so a task can compose other tasks the\nsame way as on the command line: with the `comp` function.\n\nModify the `build.boot` file such that it contains the following:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n\n(deftask hello\n  \"Print a friendly greeting.\"\n  [\u0026 [name]]\n  (fn [continue]\n    (fn [event]\n      (printf \"hello, %s!\\n\" (or name \"world\"))\n      (continue event))))\n\n(deftask hellos\n  \"Print two friendly greetings.\"\n  []\n  (comp (hello :foo) (hello :bar)))\n```\n\nNow run the new `hellos` task, which composes two instances of the `hello` task\nwith different arguments to the constructor:\n\n```\n$ boot hellos\nhello, :foo!\nhello, :bar!\n```\n\n### The Build Environment\n\nThe global build environment contains the project metadata. This includes things\nlike the project group and artifact ID, version string, dependencies, etc. The\nenvironment is accessible throughout the build process via the `get-env` and\n`set-env!` functions.\n\nFor example:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n\n(set-env!\n  :project      'com.me/my-project\n  :version      \"0.1.0-SNAPSHOT\"\n  :description  \"My Clojure project.\"\n  :url          \"http://me.com/projects/my-project\"\n  :license      {:name  \"Eclipse Public License\"\n                 :url   \"http://www.eclipse.org/legal/epl-v10.html\"}\n  :dependencies '[[tailrecursion/boot.task \"2.0.0\"]\n                  [tailrecursion/hoplon    \"5.0.0\"]]\n  :src-paths    #{\"src\"})\n\n(deftask env-value\n  \"Print the value associated with `key` in the build environment.\"\n  [key]\n  (fn [continue]\n    (fn [event]\n      (prn (get-env key))\n      (continue event))))\n```\n\nIn the example above the environment is configured using `set-env!` and a task\nis defined to print the environment value associated with a given key using\n`get-env`. (This task is similar to the core `debug` task that is included in\nboot already.) We can run the task like this:\n\n```\n$ boot [env-value :src-paths]\n#{\"src\"}\n```\n\n### Tasks That Modify The Environment\n\nTasks defined in the `build.boot` script can dynamically modify the build\nenvironment at runtime. That is, they can use `set-env!` to add dependencies or\ndirectories to the classpath or otherwise update values in the build\nenvironment. This makes it possible to define \"profile\" tasks that can be used\nto modify the behavior of other tasks. These profile-type tasks can either\ncreate a middleware function or simply return Clojure's `identity` to pass\ncontrol directly to the next task.\n\nFor example:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n\n(set-env!\n  :project      'com.me/my-project\n  :version      \"0.1.0-SNAPSHOT\"\n  :description  \"My Clojure project.\"\n  :url          \"http://me.com/projects/my-project\"\n  :license      {:name  \"Eclipse Public License\"\n                 :url   \"http://www.eclipse.org/legal/epl-v10.html\"}\n  :dependencies '[[tailrecursion/boot.task \"2.0.0\"]\n                  [tailrecursion/hoplon    \"5.0.0\"]]\n  :src-paths    #{\"src\"})\n\n(deftask env-mod\n  \"Example profile-type task.\"\n  []\n  (set-env! :description \"My TEST Clojure project.\")\n  identity)\n\n(deftask env-value\n  \"Print the value associated with `key` in the build environment.\"\n  [key]\n  (fn [continue]\n    (fn [event]\n      (prn (get-env key))\n      (continue event))))\n```\n\nNow, running this `build.boot` script produces the following:\n\n```\n$ boot [env-value :description]\n\"My Clojure project.\"\n$ boot env-mod [env-value :description]\n\"My TEST Clojure project.\"\n```\n\nIn the build script the `deftask` macro defines a function whose body is\ncompiled lazily at runtime when the function is called. This means that inside\na `deftask` you can add dependencies and require namespaces which will then\nbe available for use in the build script.\n\nFor example:\n\n```clojure\n#!/usr/bin/env boot\n\n#tailrecursion.boot.core/version \"2.5.0\"\n\n(set-env!\n  :project      'com.me/my-project\n  :version      \"0.1.0-SNAPSHOT\"\n  :description  \"My Clojure project.\"\n  :url          \"http://me.com/projects/my-project\"\n  :license      {:name  \"Eclipse Public License\"\n                 :url   \"http://www.eclipse.org/legal/epl-v10.html\"}\n  :src-paths    #{\"src\"})\n\n(deftask load-hoplon\n  \"Example profile-type task.\"\n  []\n  (set-env!\n    :dependencies '[[tailrecursion/boot.task \"2.0.0\"]\n                    [tailrecursion/hoplon    \"5.0.0\"]])\n  (require '[tailrecursion.hoplon.boot :as h])\n  identity)\n```\n\nThe `load-hoplon` task adds the dependencies needed for building a Hoplon\napplication and requires the hoplon boot task namespace, aliasing it to `h`\nlocally. To see the effect run the `build.boot` script with and without this\ntask and see how the list of available tasks changes.\n\nFirst without the `load-hoplon` profile:\n\n```\n$ boot help\ntailrecursion/boot 1.0.0: http://github.com/tailrecursion/boot\n\nUsage: boot OPTS task ...\n       boot OPTS [task arg arg] ...\n       boot OPTS [help task]\n\nOPTS:  :v       Verbose exceptions (full cause trace).\n       [:v n]   Cause trace limited to `n` elements each.\n\nTasks: debug         Print the value of a boot environment key.\n       help          Print help and usage info for a task.\n       lein          Run a leiningen task with a generated `project.clj`.\n       load-hoplon   Example profile-type task.\n       repl          Launch nrepl in the project.\n       syncdir       Copy/sync files between directories.\n       watch         Watch `:src-paths` and call its continuation when files change.\n\nCreate a minimal boot script: `boot :strap \u003e build.boot`\n\n```\n\nThen with the `load-hoplon` profile:\n\n```\n$ boot load-hoplon help\ntailrecursion/boot 1.0.0: http://github.com/tailrecursion/boot\n\nUsage: boot OPTS task ...\n       boot OPTS [task arg arg] ...\n       boot OPTS [help task]\n\nOPTS:  :v       Verbose exceptions (full cause trace).\n       [:v n]   Cause trace limited to `n` elements each.\n\nTasks: debug         Print the value of a boot environment key.\n       help          Print help and usage info for a task.\n       lein          Run a leiningen task with a generated `project.clj`.\n       load-hoplon   Example profile-type task.\n       repl          Launch nrepl in the project.\n       syncdir       Copy/sync files between directories.\n       watch         Watch `:src-paths` and call its continuation when files change.\n       h/hoplon      Build Hoplon web application.\n       h/html2cljs   Convert file from html syntax to cljs syntax.\n\nCreate a minimal boot script: `boot :strap \u003e build.boot`\n\n```\n\nNotice how the second list includes `h/hoplon` and `h/html2cljs`, the two tasks\ndefined using `deftask` in the [Hoplon boot task namespace][6]. You could run\nthe `hoplon` task, for example, by doing\n\n```\n$ boot load-hoplon h/hoplon\n```\n\n### Staging Directories And Temporary Files\n\nThe Java/Clojure build process is pretty much wedded to files in the filesystem.\nThis adds incidental complexity to the build process and causes undesired\ncoupling between tasks and between tasks and the project environment. Boot\nprovides facilities to mitigate the issues with managing the files created\nduring the build process. This allows tasks to be more general and easily\ncomposed, and eliminates configuration boilerplate in the project environment.\n\n* Tasks produce files which may be further processed by other tasks or emitted\n  into the final output directory as artifacts. Using boot's file management\n  facilities eliminates the need for the task itself to know which is the case\n  during a particular build.\n\n* Boot's file management facilities eliminate the coupling between tasks and the\n  filesystem, improving the ability to compose these tasks.\n\n* Boot manages these files in such a way as to never accumulate stale or garbage\n  files, so there is no need for a \"clean\" task. This greatly simplifies the\n  state model for the build process, making it easier to understand what's going\n  on during the build and the interactions between tasks.\n\nThe boot build process deals with six types of directories–two of which are\nspecified in the project's boot environment (in the `build.boot` file) and the\nother four are created by tasks during the build process and managed by boot.\n\n#### Project Directories\n\nThese directories contain files that are part of the project itself and are\nread-only as far as boot tasks are concerned.\n\n* **Project source directories.** These are specified in the `:src-paths` key\n  of the boot environment for the project, and boot adds them to the project's\n  class path automatically.\n\n* **Resource directories.** These are specified using the `add-sync!` function\n  in the `build.boot` file. The contents of these directories are overlayed on\n  some other directory (usually the `:out-path` dir, but it could be any\n  directory) after each build cycle. These directories contain things like CSS\n  stylesheets, image files, etc. Boot does not automatically add resource\n  directories to the project's class path.\n\n#### Boot Managed Directories\n\nThese directories contain intermediate files created by boot tasks and are\nmanaged by boot. Boot deletes managed directories created by previous builds\neach time it starts.\n\n* **Project output directory.** This is specified in the `:out-path` key of\n  the project boot environment. This is where the final artifacts produced by\n  the entire build process are placed. This directory is kept up to date and\n  free of stale artifacts by boot, automatically. Tasks should not add files\n  directly to this directory or manipulate the files it contains. Instead,\n  tasks emit artifacts to staging directories (see below) and boot takes care\n  of syncing them to the output directory at the end of each build cycle.\n\n* **Generated source directories.** These directories are created by tasks\n  via the `mksrcdir!` function. Generated source dirs are similar to the project\n  source dirs, except that tasks can write to them and they're managed by boot.\n  Tasks can use these directories as a place to put intermediate source files\n  that are generated from sources in JAR dependencies (i.e. once created these\n  files won't change from one build cycle to the next).\n\n* **Temporary directories.** Temp directories are created by tasks via the\n  `mktmp!` function. Tasks can use these directories for storing intermediate\n  files that will not be used as input for other tasks or as final compiled\n  artifacts (intermediate JavaScript namespaces created by the Google Closure\n  compiler, for instance). These directories are not automatically added to the\n  project's class path.\n\n* **Staging directories.** These directories are created by tasks via the\n  `mkoutdir!` function. Tasks emit artifacts into these staging directories\n  which are cleaned automatically by boot at the start of each build cycle.\n  Staging directories are automatically added to the project's class path so\n  the files emitted there can be used as input for other tasks (or not) as\n  required. Files in staging directories at the end of the build cycle which\n  have not been consumed by another task (see below) will be synced to the\n  output directory after all tasks in the cycle have been run.\n\n\u003cimg height=\"600px\" src=\"https://raw.github.com/tailrecursion/boot/master/img/files.gif\"\u003e\n\nThe image above illustrates the flow of files through the boot build process.\nOn the left and right sides of the image are the various directories involved\nin the build process. The build process depicted consists of two tasks, \"Task 1\"\nand \"Task 2\", colored orange and red, respectively, displayed in the center of\nthe image.\n\nTasks participate in the three phases of the build cycle: init, build, and\nfilter. The initialization phase occurs once per boot invocation for each task,\nwhen the tasks are constructed. Tasks return middleware functions which handle\nthe build phase of the process. Tasks may \"consume\" source files (see the next\nsection). These files are removed from the staging directories of all tasks by\nboot during the filter phase of the build cycle.\n\nAfter the final phase of the build cycle stale artifacts are removed from the\nproject output directory and any artifacts that remain in staging directories\nare synced over to it.\n\n### Source Files Consumed By Tasks\n\nFIXME\n\n## License\n\nCopyright © 2013 Alan Dipert and Micha Niskin\n\nDistributed under the Eclipse Public License, the same as Clojure.\n\n[1]: https://raw.github.com/tailrecursion/boot/master/img/archimedes-lever.gif\n[2]: https://clojars.org/tailrecursion/boot/latest-version.svg?cachebuster=002\n[3]: https://clojars.org/tailrecursion/boot\n[4]: https://github.com/technomancy/leiningen\n[5]: https://github.com/tailrecursion/boot.core/blob/master/src/tailrecursion/boot/core/task.clj\n[6]: https://github.com/tailrecursion/hoplon/blob/master/src/tailrecursion/hoplon/boot.clj\n[7]: https://raw.github.com/tailrecursion/boot/master/img/files.gif\n[8]: https://clojars.org/repo/tailrecursion/boot/1.1.1/boot-1.1.1.jar\n\n[10]: https://github.com/mmcgrana/ring\n[20]: https://github.com/tailrecursion/boot.task\n[30]: https://github.com/technomancy/leiningen/blob/master/doc/PROFILES.md\n[50]: https://github.com/tailrecursion/boot/blob/master/boot.edn\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftailrecursion%2Fboot","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftailrecursion%2Fboot","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftailrecursion%2Fboot/lists"}