anchor.diff:                                                      let result = Subsystem.processMessages renderMessages renderer world
                                                       SDL.SDL_RenderPresent renderContext
                                                       result)
  -                                        
  -                                                // start the audio thread
  -                                                let audioPlayerThread = Task.Factory.StartNew (fun () ->
  -                                                    Subsystem.processMessages audioMessages audioPlayer world)
  -
  -                                                // fin
  -                                                (Some rendererThread, Some audioPlayerThread, world)
  -                                            | (_, _) -> (None, None, world)
  +                                                (Some rendererThread, world)
  +                                            | None -> (None, world)
  +
  +                                        // attempt to start audio player thread
  +                                        let (audioPlayerThreadOpt, world) =
  +                                            if SDL.SDL_WasInit SDL.SDL_INIT_AUDIO <> 0u then
  +                                                let audioPlayer = World.getAudioPlayer world
  +                                                let (audioMessages, audioPlayer) = Subsystem.popMessages audioPlayer
  +                                                let world = World.setAudioPlayer audioPlayer world
  +                                                let audioPlayerThread = Task.Factory.StartNew (fun () -> Subsystem.processMessages audioMessages audioPlayer world)
  +                                                (Some audioPlayerThread, world)
  +                                            else (None, world)
   
                                           // post-process the world
  -                                        let world = post world
  +                                        let world = postProcess world
                                           let world = World.updateTickTime world
                                           let world = World.incrementUpdateCount world
   
                                           // recur
  -                                        World.runWithoutCleanUp runWhile pre post sdlDeps liveness rendererThreadOpt audioPlayerThreadOpt world
  +                                        World.runWithoutCleanUp runWhile preProcess postProcess sdlDeps liveness rendererThreadOpt audioPlayerThreadOpt world
   
                                       | Exiting -> world
                                   | Exiting -> world
  
positive.code:                                     match World.getLiveness world with
                                      | Running ->
  
                                          // attempt to finish threads
                                          let world =
                                              match (rendererThreadOpt, audioPlayerThreadOpt) with
                                              | ((Some rendererThread), (Some audioPlayerThread)) ->
  
                                                  // finish all threads
                                                  let rendererResult = rendererThread |> Async.AwaitTask |> Async.RunSynchronously
                                                  let audioPlayerResult = audioPlayerThread |> Async.AwaitTask |> Async.RunSynchronously
  
                                                  // apply their results
                                                  let world = Subsystem.applyResult rendererResult (World.getRenderer world) world
                                                  let world = Subsystem.applyResult audioPlayerResult (World.getAudioPlayer world) world
  
                                                  // fin
                                                  world
                                              | (_, _) -> world
  
                                          // attempt to start threads
                                          let (rendererThreadOpt, audioPlayerThreadOpt, world) =
                                              match (SdlDeps.getRenderContextOpt sdlDeps, SDL.SDL_WasInit SDL.SDL_INIT_AUDIO <> 0u) with
                                              | (Some renderContext, true) ->
  
                                                  // grab subsystem references
                                                  let renderer = World.getRenderer world
                                                  let audioPlayer = World.getAudioPlayer world
                                                              
                                                  // pop their messages
                                                  let (renderMessages, renderer) = Subsystem.popMessages renderer
                                                  let (audioMessages, audioPlayer) = Subsystem.popMessages audioPlayer
                                                              
                                                  // update popped subsystems
                                                  let world = World.setRenderer renderer world
                                                  let world = World.setAudioPlayer audioPlayer world
                                          
                                                  // start the renderer thread
                                                  let rendererThread = Task.Factory.StartNew (fun () ->
                                                      match Constants.Render.ScreenClearing with
                                                      | NoClear -> ()
  
negative.code:             World.cleanUpSubsystems world |> ignore
  
          /// Run the game engine with the given handlers, but don't clean up at the end, and return the world.
          static member runWithoutCleanUp runWhile preProcess postProcess sdlDeps liveness rendererThreadOpt audioPlayerThreadOpt world =
              if runWhile world then
                  let world = preProcess world
                  match liveness with
                  | Running ->
                      let (liveness, world) = World.processInput world
  