anchor.diff:      ["error", ex.Message] |> dict |> toJson |> replyChannel
   
   let updateState (checker: FSharpChecker) (state: State) (msg: Parser.Message) =
  -    let isWatchCompilation (project: Project) sourceFile =
  -        let compiled =
  -            if not project.IsWatchCompile then
  -                IO.File.GetLastWriteTime(sourceFile) > project.TimeStamp
  -            elif isOptimizeWatch msg.extra then
  -                true
  -            else
  -                // If the project has been compiled previously we need to check
  -                // the timestamps of all files, as the bundler may send new requests
  -                // for files not modified if they were errored in the previous compilation
  -                project.ProjectOptions.SourceFiles
  -                |> Seq.exists (fun file -> IO.File.GetLastWriteTime(file) > project.TimeStamp)
  -        if compiled then
  -            Log.logVerbose(lazy ("Watch compile triggered by: " + getRelativePath sourceFile))
  -        compiled
  +    let getDirtyFiles (project: Project) sourceFile =
  +        if IO.File.GetLastWriteTime(sourceFile) > project.TimeStamp then
  +            project.ProjectOptions.SourceFiles
  +            |> Array.filter (fun file -> IO.File.GetLastWriteTime(file) > project.TimeStamp)
  +        else [||]
       let addOrUpdateProject state (project: Project) =
           let state = Map.add project.ProjectFile project state
           true, state, project
       let tryFindAndUpdateProject state ext sourceFile =
           let checkWatchCompilation project sourceFile =
  -            // Log.logVerbose(lazy sprintf "Ownership: %s > %s"
  -            //     (getRelativePath project.ProjectFile) (getRelativePath sourceFile))
  -            // Watch compilation of an .fs file, restart project with old options
  -            if isWatchCompilation project sourceFile then
  -                createProject checker true (Some project) msg project.ProjectFile
  +            // Check if there are dirty files
  +            let dirtyFiles = getDirtyFiles project sourceFile
  +            if Array.length dirtyFiles > 0 then
  +                createProject checker dirtyFiles (Some project) msg project.ProjectFile
                   |> addOrUpdateProject state |> Some
               else Some(false, state, project)
           match msg.extra.TryGetValue("projectFile") with
  
positive.code:             projectOptions, fableCore
      let implFiles, errors =
          match prevProject with
          | Some prevProject when msg.path.EndsWith(".fs") && isOptimizeWatch msg.extra ->
              Log.logAlways(sprintf "Parsing %s..." (getRelativePath msg.path))
              let source = IO.File.ReadAllText(msg.path)
              // About this parameter, see https://github.com/fsharp/FSharp.Compiler.Service/issues/796#issuecomment-333094956
              let version = IO.File.GetLastWriteTime(msg.path).Ticks |> int
              let results, answer =
                  checker.ParseAndCheckFileInProject(msg.path, version, source, projectOptions)
                  |> Async.RunSynchronously
              match answer with
              | FSharpCheckFileAnswer.Aborted -> failwith "Aborted"
              | FSharpCheckFileAnswer.Succeeded res ->
                  match res.ImplementationFiles with
                  | None -> failwith "No Implementation files"
                  | Some implFiles ->
                      (prevProject.ImplementationFiles, implFiles) ||> List.fold (fun implFiles file ->
                          Map.add (Path.normalizePath file.FileName) file implFiles), res.Errors
          | _ ->
              Log.logAlways(sprintf "Parsing %s..." (getRelativePath projectOptions.ProjectFileName))
              let checkedProject =
                  projectOptions
                  |> checker.ParseAndCheckProject
                  |> Async.RunSynchronously
              tryGetOption "saveAst" msg.extra |> Option.iter (fun dir ->
  
negative.code:     | true, value -> Some value
      | false, _ -> None
  
  let createProject checker dirtyFiles (prevProject: Project option) (msg: Parser.Message) projFile =
      let isWatchCompile = Array.length dirtyFiles > 0
      let projectOptions, fableCore =
          match prevProject with
          | Some prevProject ->
              prevProject.ProjectOptions, prevProject.FableCore
          | None ->
              let projectOptions, fableCore =
  