                  (binding [*out* *err*]
                    (println "tire-iron not initialized"))))))
 
+     'start-watch (wrap (fn [repl-env analyzer-env [_ & opts] repl-opts]
+                          (let [passed-settings (apply hash-map opts)
+                                exec (Executors/newSingleThreadExecutor
+                                       (reify ThreadFactory
+                                         (newThread [this runnable]
+                                           (doto (Thread. runnable
+                                                          "tire-iron-watcher-thread")
+                                             (.setDaemon true)))))]
+                            (if-let [r @refresher]
+                              (do @initial-build-complete?
+                                  (alter-var-root #'watch-exec (constantly exec))
+                                  (start-watch watch-exec
+                                               (FileSystems/getDefault)
+                                               (merge {:refresher r
+                                                       :tracker tracker
+                                                       :source-dirs source-dirs
+                                                       :disable-unload @disable-unload
+                                                       :disable-load @disable-load
+                                                       :repl-env repl-env
+                                                       :analyzer-env analyzer-env
+                                                       :repl-opts repl-opts
+                                                       :compiler-env env/*compiler*}
+                                                      closed-settings
+                                                      passed-settings)))
+                              (binding [*out* *err*]
+                                (println "tire-iron not initialized"))))))
+
+     'stop-watch (wrap (fn [_ _ _ _]
+                         (stop-watch)))
+
      'init
      (wrap (fn [repl-env analyzer-env _ repl-opts]
-             (let [refresher (or @refresher
+             (let [env env/*compiler*
+                   ^Runnable build #(try
+                                      (closure/build (apply build/inputs source-dirs)
+                                                     repl-opts
+                                                     env)
+                                      (finally
+                                        (deliver initial-build-complete? true)))
+                   ;; Kick off a build. That will speed up the first reload which
+                   ;; takes the longest to build.
+                   _ (.start (Thread. build))
+                   refresher (or @refresher
                                  (reset! refresher
-                                         (determine-refresher repl-env)))
-                   env env/*compiler*
-                   ^Runnable build #(do (closure/build (apply build/inputs source-dirs)
-                                                       repl-opts
-                                                       env)
-                                        (deliver initial-build-complete? true))]
+                                         (determine-refresher repl-env)))]
                (-initialize refresher
                             {:repl-env repl-env
                              :analyzer-env analyzer-env
-                             :repl-opts repl-opts})
-               ;; Kick off a build. That will speed up the first reload which
-               ;; takes the longest to build.
-               (.start (Thread. build)))))
+                             :repl-opts repl-opts}))))
 
      'print-disabled
      (wrap (fn [& _]

                        before
                        after
                        state
                        add-all?]}]
  (doseq [s (filter some? [before after state])]
    (assert (symbol? s) "value must be a symbol")
    (assert (namespace s)

      {source-dirs ["src"]}}]
  (let [refresher (atom refresher)
        tracker (atom (track/tracker))
        initial-build-complete? (promise)
        disable-unload (atom (into #{} disable-unload))
        disable-load (atom (into #{'cljs.core
                                   'clojure.browser.repl
                                   'clojure.browser.net}
                                 disable-load))
        closed-settings (select-keys closed-settings
                                     [:before
                                      :after
