anchor.diff:                  World.cleanUp
                   sdlConfig
   
  -        static member private pairWithName source =
  -            (Reflection.getTypeName source, source)
  -
  -        static member private pairWithNames sources =
  -            Map.ofListBy World.pairWithName sources
  +        /// The empty world.
  +        static member empty =
  +            // NOTE: implemented with memoization since adding a 'field' with a type extension must be done with a property
  +            match OptEmptyWorld with
  +            | Some emptyWorld -> emptyWorld
  +            | None ->
  +                let emptyWorld = World.makeEmpty ()
  +                OptEmptyWorld <- Some emptyWorld
  +                emptyWorld
  +
  +        static member private init () =
  +
  +            // init only if needed
  +            if not Initialized then
  +
  +                // make types load reflectively from pathed (non-static) assemblies
  +                AppDomain.CurrentDomain.AssemblyLoad.Add
  +                    (fun args -> LoadedAssemblies.[args.LoadedAssembly.FullName] <- args.LoadedAssembly)
  +                AppDomain.CurrentDomain.add_AssemblyResolve ^ ResolveEventHandler
  +                    (fun _ args -> snd ^ LoadedAssemblies.TryGetValue args.Name)
  +
  +                // ensure the current culture is invariate
  +                System.Threading.Thread.CurrentThread.CurrentCulture <-
  +                    System.Globalization.CultureInfo.InvariantCulture
  +
  +                // init logging
  +                Log.init ^ Some "Log.txt"
  +
  +                // init type converters
  +                Math.initTypeConverters ()
  +
  +                // init F# reach-arounds
  +                // TODO: define this somewhere else...
  +                World.rebuildEntityTree <- fun screen world ->
  +                    let tree = QuadTree.make Constants.Engine.EntityTreeDepth Constants.Engine.EntityTreeBounds
  +                    let entities = screen |> flip World.proxyGroups world |> Seq.map (flip World.proxyEntities world) |> Seq.concat
  +                    for entity in entities do
  +                        let entityMaxBounds = World.getEntityMaxBounds entity world
  +                        QuadTree.addElement false entityMaxBounds entity tree
  +                    (world, tree)
  +
  +                // mark init flag
  +                Initialized <- true
  +
  +        static member private makeEmpty () =
  +
  +            // init world
  +            World.init ()
  +
  +            // make the world's subsystems
  +            let subsystems =
  +                let physicsEngineSubsystem = PhysicsEngineSubsystem.make Constants.Engine.DefaultSubsystemOrder { MockPhysicsEngine = () } :> Subsystem
  +                let rendererSubsystem = RendererSubsystem.make Constants.Engine.DefaultSubsystemOrder { MockRenderer = () } :> Subsystem
  +                let audioPlayerSubsystem = AudioPlayerSubsystem.make Constants.Engine.DefaultSubsystemOrder { MockAudioPlayer = () } :> Subsystem
  +                { SubsystemMap =
  +                    Map.ofList
  +                        [(Constants.Engine.PhysicsEngineSubsystemName, physicsEngineSubsystem)
  +                         (Constants.Engine.RendererSubsystemName, rendererSubsystem)
  +                         (Constants.Engine.AudioPlayerSubsystemName, audioPlayerSubsystem)] }
  +
  +            // make default facets
  +            let defaultFacets =
  +                Map.ofList
  +                    [(typeof<RigidBodyFacet>.Name, RigidBodyFacet () :> Facet)
  +                     (typeof<SpriteFacet>.Name, SpriteFacet () :> Facet)
  +                     (typeof<AnimatedSpriteFacet>.Name, AnimatedSpriteFacet () :> Facet)]
  +
  +            // make default entity dispatchers
  +            // TODO: see if we can reflectively generate these
  +            let defaultEntityDispatchers =
  +                Map.ofListBy World.pairWithName ^
  +                    [EntityDispatcher ()
  +                     GuiDispatcher () :> EntityDispatcher
  +                     ButtonDispatcher () :> EntityDispatcher
  +                     LabelDispatcher () :> EntityDispatcher
  +                     TextDispatcher () :> EntityDispatcher
  +                     ToggleDispatcher () :> EntityDispatcher
  +                     FeelerDispatcher () :> EntityDispatcher
  +                     FillBarDispatcher () :> EntityDispatcher
  +                     BlockDispatcher () :> EntityDispatcher
  +                     BoxDispatcher () :> EntityDispatcher
  +                     TopViewCharacterDispatcher () :> EntityDispatcher
  +                     SideViewCharacterDispatcher () :> EntityDispatcher
  +                     TileMapDispatcher () :> EntityDispatcher]
  +
  +            // make default group dispatchers
  +            let defaultGroupDispatchers = Map.ofList [World.pairWithName ^ GroupDispatcher ()]
  +            
  +            // make default screen dispatchers
  +            let defaultScreenDispatchers = Map.ofList [World.pairWithName ^ ScreenDispatcher ()]
  +
  +            // make default game dispatcher
  +            let activeGameDispatcher = GameDispatcher ()
  +            let defaultGameDispatchers = Map.ofList [World.pairWithName activeGameDispatcher]
  +
  +            // make the world's components
  +            let components =
  +                { EntityDispatchers = defaultEntityDispatchers
  +                  GroupDispatchers = defaultGroupDispatchers
  +                  ScreenDispatchers = defaultScreenDispatchers
  +                  GameDispatchers = defaultGameDispatchers
  +                  Facets = defaultFacets }
  +
  +            // make the world's callbacks
  +            let callbacks =
  +                { Subscriptions = Map.empty
  +                  Unsubscriptions = Map.empty
  +                  Tasklets = Queue.empty
  +                  CallbackStates = Map.empty }
  +
  +            // make the world's state
  +            let worldState =
  +                { TickRate = 1L
  +                  TickTime = 0L
  +                  UpdateCount = 0L
  +                  Liveness = Running
  +                  OptScreenTransitionDestination = None
  +                  AssetMetadataMap = Map.empty
  +                  AssetGraphFilePath = String.Empty
  +                  OverlayRouter = OverlayRouter.make (Map.ofList [World.pairWithName defaultEntityDispatchers]) []
  +                  OverlayFilePath = String.Empty
  +                  Overlayer = Overlayer.makeEmpty ()
  +                  Camera = { EyeCenter = Vector2.Zero; EyeSize = Vector2 (single Constants.Render.ResolutionXDefault, single Constants.Render.ResolutionYDefault) }
  +                  OptEntityCache = Unchecked.defaultof<KeyedCache<Entity Address * World, EntityState option>>
  +                  Clipboard = None
  +                  UserState = () }
  +
  +            // make the simulant states
  +            let simulantStates =
  +                (World.makeGameState activeGameDispatcher, Map.empty)
  +
  +            // make the world itself
  +            let world =
  +                { Subsystems = subsystems
  +                  Components = components
  +                  Callbacks = callbacks
  +                  State = worldState
  +                  SimulantStates = simulantStates }
  +
  +            // initialize OptEntityCache after the fact due to back reference
  +            let world = { world with State = { world.State with OptEntityCache = KeyedCache.make (Address.empty<Entity>, world) None }}
  +            
  +            // finally, register the game (which does nothing since it uses the vanilla GameDispatcher)
  +            World.registerGame world
   
           /// Try to make the world, returning either a Right World on success, or a Left string
           /// (with an error message) on failure.
           static member attemptMake useLoadedGameDispatcher tickRate userState (plugin : NuPlugin) sdlDeps =
   
  +            // start with an empty world value, and then transform it as needed
  +            let world = World.empty
  +
               // attempt to generate asset metadata so the rest of the world can be created
               match Metadata.tryGenerateAssetMetadataMap Constants.Assets.AssetGraphFilePath with
               | Right assetMetadataMap ->
   
  -                // make the world's subsystems
  +                // add subsystems from plug-in
  +                let subsystems = world.Subsystems
                   let subsystems =
  -                    let userSubsystems = Map.ofList ^ plugin.MakeSubsystems ()
  +                    let userSubsystems = plugin.MakeSubsystems ()
                       let physicsEngine = PhysicsEngine.make Constants.Physics.Gravity
                       let physicsEngineSubsystem = PhysicsEngineSubsystem.make Constants.Engine.DefaultSubsystemOrder physicsEngine :> Subsystem
                       let renderer =
  
positive.code:     let private SplashScreenUpdateKey = World.makeSubscriptionKey ()
  
      type World with
  
          /// Ignore all handled events.
          static member handleAsPass<'a, 's when 's :> Simulant> (_ : Event<'a, 's>) (world : World) =
  
negative.code: [<AutoOpen; CompilationRepresentation (CompilationRepresentationFlags.ModuleSuffix)>]
  module WorldModule =
  
      let mutable private Initialized = false
      let mutable private OptEmptyWorld = None
      let private LoadedAssemblies = Dictionary<string, Assembly> HashIdentity.Structural
      let private ScreenTransitionMouseLeftKey = World.makeSubscriptionKey ()
      let private ScreenTransitionMouseCenterKey = World.makeSubscriptionKey ()
      let private ScreenTransitionMouseRightKey = World.makeSubscriptionKey ()
  