anchor.diff:          subsystems.Remove subsystemName
   
       override this.ProcessUpdate ecs world =
  -        let _ = Vsync.RunSynchronously (processParallel (fun system -> system.ProcessUpdate ecs))
  -        world
  +        let results =
  +            subsystems |>
  +            Seq.map (fun entry -> Task.Run (fun () ->
  +                let system = entry.Value
  +                do ecs.RegisterPipedValue system.PipedKey system.PipedInit
  +                let _ = system.ProcessUpdate ecs Unchecked.defaultof<'w>
  +                ecs.IndexPipedValue<obj> system.PipedKey) |> Vsync.AwaitTaskT) |>
  +            Vsync.Parallel
  +        processUpdateResults results world
   
       override this.ProcessPostUpdate ecs world =
  -        let _ = Vsync.RunSynchronously (processParallel (fun system -> system.ProcessPostUpdate ecs))
  -        world
  +        let results =
  +            subsystems |>
  +            Seq.map (fun entry -> Task.Run (fun () ->
  +                let system = entry.Value
  +                do ecs.RegisterPipedValue system.PipedKey system.PipedInit
  +                let _ = system.ProcessPostUpdate ecs Unchecked.defaultof<'w>
  +                ecs.IndexPipedValue<obj> system.PipedKey) |> Vsync.AwaitTaskT) |>
  +            Vsync.Parallel
  +        processPostUpdateResults results world
   
       override this.ProcessActualize ecs world =
  -        let _ = Vsync.RunSynchronously (processParallel (fun system -> system.ProcessActualize ecs))
  -        world
  +        let results =
  +            subsystems |>
  +            Seq.map (fun entry -> Task.Run (fun () ->
  +                let system = entry.Value
  +                do ecs.RegisterPipedValue system.PipedKey system.PipedInit
  +                let _ = system.ProcessActualize ecs Unchecked.defaultof<'w>
  +                ecs.IndexPipedValue<obj> system.PipedKey) |> Vsync.AwaitTaskT) |>
  +            Vsync.Parallel
  +        processActualizeResults results world
   
       type 'w Ecs with
   
  
positive.code: type [<AbstractClass>] 'w System () =
      let pipedKey = Gen.id
      member this.PipedKey with get () = pipedKey
      abstract ProcessUpdate : 'w Ecs -> 'w -> 'w
      default this.ProcessUpdate _ world = world
      abstract ProcessPostUpdate : 'w Ecs -> 'w -> 'w
  
negative.code:                     | (false, _) -> this.Correlations.Add (entityId, List [systemName])
              | _ -> failwith ("Could not find expected system '" + systemName + "'.")
  
  /// A collection of systems that can be run in parallel.
  /// Because 'w is not a monoid (no mappend), null is passed in to all subsystems. Any information that affects the
  /// world has to use a piped value and the related process lambda.
  type 'w SystemParallel (processUpdateResults, processPostUpdateResults, processActualizeResults) =
      inherit System<'w> ()
  
      let subsystems =
          dictPlus [] : Dictionary<string, 'w System>
  
      member this.RegisterSubsystem subsystemName subsystem =
          subsystems.[subsystemName] <- subsystem
  
  