                           not Enum.any?(entries, fn { _b, _m, s, _d } -> s == i end),
                           do: i
 
-      if stale != [] do
-        { :ok, pid } = :gen_server.start_link(__MODULE__, entries, [])
-
-        try do
-          files_to_path(pid, entries, stale, compile_path, File.cwd)
-          :gen_server.cast(pid, :merge)
-        after
-          :gen_server.call(pid, { :stop, manifest })
-        end
+      cond do
+        stale != [] ->
+          on_start.()
+          { :ok, pid } = :gen_server.start_link(__MODULE__, entries, [])
+
+          try do
+            do_files_to_path(pid, entries, stale, compile_path, File.cwd)
+            :gen_server.cast(pid, :merge)
+          after
+            :gen_server.call(pid, { :stop, manifest })
+          end
+
+          :ok
+        all_entries != entries ->
+          :ok
+        true ->
+          :noop
       end
     end
 

  in between modules, which helps it recompile only the modules that
  have changed at runtime.
  """
  defdelegate files_to_path(manifest, stale, all, path), to: ManifestCompiler

  defp set_compiler_opts(project, opts, extra) do
    opts = Dict.take(opts, [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors])

      end
    end

    defp do_files_to_path(_pid, _entries, [], _compile_path, _cwd), do: :ok
    defp do_files_to_path(pid, entries, files, compile_path, cwd) do
      Kernel.ParallelCompiler.files :lists.usort(files),
        each_module: each_module(pid, compile_path, cwd, &1, &2, &3),
        each_file: each_file(&1),
        each_waiting: each_waiting(entries, &1)

      do_files_to_path(pid, entries, :gen_server.call(pid, :next), compile_path, cwd)
    end

    defp each_module(pid, compile_path, cwd, source, module, binary) do
