         (fn [state source-name]
           (let [src (get-in state [:sources source-name])
                 compiled-src (generate-output-for-source state src)]
-            (-> state
-                (assoc-in [:sources source-name] compiled-src)
-                (cond->
-                  (not= (:compiled-at src)
-                        (:compiled-at compiled-src))
-                  (update :compiled conj source-name)
-                  ))))
-        (assoc state :compiled [])
+            (assoc-in state [:sources source-name] compiled-src)))
+        state
         source-names))))
 
 (defn par-compile-one
-  [state ready-ref compiled-ref errors-ref source-name]
+  [state ready-ref errors-ref source-name]
   (let [{:keys [requires] :as src}
         (get-in state [:sources source-name])]
 


  ;; if only one module is defined we dont need all this work
  (if (= 1 (count modules))
    (vals modules)
    ;; else: multiple modules must be sorted in dependency order
    (let [module-graph
          (module-graph modules)

            tasks
            (->> (for [source-name source-names]
                   ;; bound-fn for with-compiler-state
                   (let [task-fn (bound-fn [] (par-compile-one state ready errors source-name))]
                     (.submit exec ^Callable task-fn)))
                 (doall) ;; force submit all, then deref
                 (into [] (map deref)))]
