From f8b38dc8f21b7cd23295d07e5425dd0aa999dc28 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 25 Sep 2022 12:10:30 +0200
Subject: [PATCH 01/31] Fix imports, refactor builders, invert feature flag

---
 maplibre/Cargo.toml                           |   3 +-
 maplibre/src/context.rs                       |   4 +-
 maplibre/src/environment.rs                   |  68 +++++-
 maplibre/src/headless.rs                      |   7 +-
 maplibre/src/io/apc.rs                        |   7 +-
 maplibre/src/io/scheduler.rs                  |   4 +-
 maplibre/src/io/source_client.rs              |   6 +-
 maplibre/src/lib.rs                           | 222 +-----------------
 maplibre/src/map.rs                           |  47 ++++
 maplibre/src/map_schedule.rs                  |   6 +-
 maplibre/src/platform/noweb/http_client.rs    |   3 +-
 maplibre/src/platform/noweb/scheduler.rs      |   3 +-
 maplibre/src/render/builder.rs                |  76 ++++++
 maplibre/src/render/mod.rs                    |   8 +-
 maplibre/src/render/render_commands.rs        |  16 +-
 maplibre/src/render/render_phase/draw.rs      |   3 +-
 maplibre/src/render/resource/surface.rs       |   2 +-
 maplibre/src/render/stages/extract_stage.rs   |   3 +-
 .../src/render/stages/graph_runner_stage.rs   |   2 +-
 .../src/render/stages/phase_sort_stage.rs     |   3 +-
 maplibre/src/render/stages/queue_stage.rs     |   2 +-
 maplibre/src/render/stages/resource_stage.rs  |   2 +-
 maplibre/src/render/stages/upload_stage.rs    |   3 +-
 maplibre/src/stages/mod.rs                    |   3 +-
 .../src/stages/populate_tile_store_stage.rs   |   2 +-
 maplibre/src/stages/request_stage.rs          |   3 +-
 maplibre/src/window.rs                        |   4 +-
 web/Cargo.toml                                |   2 +-
 28 files changed, 249 insertions(+), 265 deletions(-)
 create mode 100644 maplibre/src/map.rs
 create mode 100644 maplibre/src/render/builder.rs

diff --git a/maplibre/Cargo.toml b/maplibre/Cargo.toml
index 0367c17d..02a13596 100644
--- a/maplibre/Cargo.toml
+++ b/maplibre/Cargo.toml
@@ -9,10 +9,11 @@ description = "Native Maps for Web, Mobile and Desktop"
 readme = "../README.md"
 
 [features]
+default = ["thread-safe-futures"]
 web-webgl = ["wgpu/webgl"]
 # Enable tracing using tracy on desktop/mobile and the chrome profiler on web
 trace = ["tracing-subscriber", "tracing-tracy", "tracy-client"]
-no-thread-safe-futures = []
+thread-safe-futures = []
 embed-static-tiles = ["maplibre-build-tools/sqlite"]
 headless = ["png"]
 
diff --git a/maplibre/src/context.rs b/maplibre/src/context.rs
index 5f99755d..8b3f196c 100644
--- a/maplibre/src/context.rs
+++ b/maplibre/src/context.rs
@@ -2,12 +2,14 @@ use std::ops::Div;
 
 use cgmath::Angle;
 
+use crate::render::Renderer;
+use crate::style::Style;
+use crate::window::WindowSize;
 use crate::{
     coords::{LatLon, ViewRegion, WorldCoords, Zoom, ZoomLevel, TILE_SIZE},
     io::tile_repository::TileRepository,
     render::camera::{Camera, Perspective, ViewProjection},
     util::ChangeObserver,
-    Renderer, Style, WindowSize,
 };
 
 /// Stores the camera configuration.
diff --git a/maplibre/src/environment.rs b/maplibre/src/environment.rs
index 42e7697d..cc5ed371 100644
--- a/maplibre/src/environment.rs
+++ b/maplibre/src/environment.rs
@@ -1,12 +1,12 @@
-use crate::{
-    io::{
-        apc::AsyncProcedureCall,
-        transferables::{
-            DefaultTessellatedLayer, DefaultTileTessellated, DefaultUnavailableLayer, Transferables,
-        },
+use crate::io::scheduler::Scheduler;
+use crate::io::source_client::HttpClient;
+use crate::io::{
+    apc::AsyncProcedureCall,
+    transferables::{
+        DefaultTessellatedLayer, DefaultTileTessellated, DefaultUnavailableLayer, Transferables,
     },
-    HttpClient, MapWindowConfig, Scheduler,
 };
+use crate::window::MapWindowConfig;
 
 pub trait Environment: 'static {
     type MapWindowConfig: MapWindowConfig;
@@ -17,3 +17,57 @@ pub trait Environment: 'static {
 
     type Transferables: Transferables;
 }
+
+pub struct Kernel<E: Environment> {
+    map_window_config: E::MapWindowConfig,
+    apc: E::AsyncProcedureCall,
+    scheduler: E::Scheduler,
+    http_client: E::HttpClient,
+}
+
+pub struct KernelBuilder<E: Environment> {
+    map_window_config: Option<E::MapWindowConfig>,
+    apc: Option<E::AsyncProcedureCall>,
+    scheduler: Option<E::Scheduler>,
+    http_client: Option<E::HttpClient>,
+}
+
+impl<E: Environment> KernelBuilder<E> {
+    pub fn new() -> Self {
+        Self {
+            scheduler: None,
+            apc: None,
+            http_client: None,
+            map_window_config: None,
+        }
+    }
+
+    pub fn with_map_window_config(mut self, map_window_config: E::MapWindowConfig) -> Self {
+        self.map_window_config = Some(map_window_config);
+        self
+    }
+
+    pub fn with_scheduler(mut self, scheduler: E::Scheduler) -> Self {
+        self.scheduler = Some(scheduler);
+        self
+    }
+
+    pub fn with_apc(mut self, apc: E::AsyncProcedureCall) -> Self {
+        self.apc = Some(apc);
+        self
+    }
+
+    pub fn with_http_client(mut self, http_client: E::HttpClient) -> Self {
+        self.http_client = Some(http_client);
+        self
+    }
+
+    pub fn build(self) -> Kernel<E> {
+        Kernel {
+            scheduler: self.scheduler.unwrap(),     // TODO: Remove unwrap
+            apc: self.apc.unwrap(),                 // TODO: Remove unwrap
+            http_client: self.http_client.unwrap(), // TODO: Remove unwrap
+            map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
+        }
+    }
+}
diff --git a/maplibre/src/headless.rs b/maplibre/src/headless.rs
index bf42c702..98b20784 100644
--- a/maplibre/src/headless.rs
+++ b/maplibre/src/headless.rs
@@ -12,6 +12,12 @@ use std::{
 use tokio::{runtime::Handle, task};
 use wgpu::{BufferAsyncError, BufferSlice};
 
+use crate::environment::Environment;
+use crate::io::scheduler::Scheduler;
+use crate::io::source_client::HttpClient;
+use crate::render::Renderer;
+use crate::style::Style;
+use crate::window::{MapWindow, MapWindowConfig, WindowSize};
 use crate::{
     context::{MapContext, ViewState},
     coords::{LatLon, ViewRegion, WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
@@ -37,7 +43,6 @@ use crate::{
         RenderState,
     },
     schedule::{Schedule, Stage},
-    Environment, HttpClient, MapWindow, MapWindowConfig, Renderer, Scheduler, Style, WindowSize,
 };
 
 pub struct HeadlessMapWindowConfig {
diff --git a/maplibre/src/io/apc.rs b/maplibre/src/io/apc.rs
index 08f74c39..057153ff 100644
--- a/maplibre/src/io/apc.rs
+++ b/maplibre/src/io/apc.rs
@@ -10,6 +10,8 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
+use crate::io::scheduler::Scheduler;
+use crate::io::source_client::HttpClient;
 use crate::{
     coords::WorldTileCoords,
     io::{
@@ -17,7 +19,6 @@ use crate::{
         transferables::{DefaultTransferables, Transferables},
         TileRequest,
     },
-    Environment, HttpClient, Scheduler,
 };
 
 /// The result of the tessellation of a tile.
@@ -41,9 +42,9 @@ pub trait Context<T: Transferables, HC: HttpClient>: Send + 'static {
     fn source_client(&self) -> &SourceClient<HC>;
 }
 
-#[cfg(not(feature = "no-thread-safe-futures"))]
+#[cfg(feature = "thread-safe-futures")]
 pub type AsyncProcedureFuture = Pin<Box<(dyn Future<Output = ()> + Send + 'static)>>;
-#[cfg(feature = "no-thread-safe-futures")]
+#[cfg(not(feature = "thread-safe-futures"))]
 pub type AsyncProcedureFuture = Pin<Box<(dyn Future<Output = ()> + 'static)>>;
 
 pub type AsyncProcedure<C> = fn(input: Input, context: C) -> AsyncProcedureFuture;
diff --git a/maplibre/src/io/scheduler.rs b/maplibre/src/io/scheduler.rs
index 3053d361..912436d3 100644
--- a/maplibre/src/io/scheduler.rs
+++ b/maplibre/src/io/scheduler.rs
@@ -7,7 +7,7 @@ use crate::error::Error;
 /// Async/await scheduler.
 /// Can schedule a task from a future factory and a shared state.
 pub trait Scheduler: 'static {
-    #[cfg(not(feature = "no-thread-safe-futures"))]
+    #[cfg(feature = "thread-safe-futures")]
     fn schedule<T>(
         &self,
         future_factory: impl (FnOnce() -> T) + Send + 'static,
@@ -15,7 +15,7 @@ pub trait Scheduler: 'static {
     where
         T: Future<Output = ()> + Send + 'static;
 
-    #[cfg(feature = "no-thread-safe-futures")]
+    #[cfg(not(feature = "thread-safe-futures"))]
     fn schedule<T>(
         &self,
         future_factory: impl (FnOnce() -> T) + Send + 'static,
diff --git a/maplibre/src/io/source_client.rs b/maplibre/src/io/source_client.rs
index 3f3caaf9..ba432d09 100644
--- a/maplibre/src/io/source_client.rs
+++ b/maplibre/src/io/source_client.rs
@@ -12,9 +12,9 @@ pub type HTTPClientFactory<HC> = dyn Fn() -> HC;
 /// [https://github.com/dtolnay/async-trait/blob/b70720c4c1cc0d810b7446efda44f81310ee7bf2/README.md#non-threadsafe-futures](https://github.com/dtolnay/async-trait/blob/b70720c4c1cc0d810b7446efda44f81310ee7bf2/README.md#non-threadsafe-futures)
 ///
 /// Users of this library can decide whether futures from the HTTPClient are thread-safe or not via
-/// the future "no-thread-safe-futures". Tokio futures are thread-safe.
-#[cfg_attr(feature = "no-thread-safe-futures", async_trait(?Send))]
-#[cfg_attr(not(feature = "no-thread-safe-futures"), async_trait)]
+/// the future "thread-safe-futures". Tokio futures are thread-safe.
+#[cfg_attr(not(feature = "thread-safe-futures"), async_trait(?Send))]
+#[cfg_attr(feature = "thread-safe-futures", async_trait)]
 pub trait HttpClient: Clone + Sync + Send + 'static {
     async fn fetch(&self, url: &str) -> Result<Vec<u8>, Error>;
 }
diff --git a/maplibre/src/lib.rs b/maplibre/src/lib.rs
index 082fdcd3..9e8ac6db 100644
--- a/maplibre/src/lib.rs
+++ b/maplibre/src/lib.rs
@@ -16,24 +16,6 @@
 //! maplibre = "0.0.2"
 //! ```
 
-use std::{
-    borrow::{Borrow, BorrowMut},
-    cell::RefCell,
-    rc::Rc,
-};
-
-use crate::{
-    environment::Environment,
-    io::{scheduler::Scheduler, source_client::HttpClient},
-    map_schedule::InteractiveMapSchedule,
-    render::{
-        settings::{RendererSettings, WgpuSettings},
-        RenderState, Renderer,
-    },
-    style::Style,
-    window::{EventLoop, HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
-};
-
 pub mod context;
 pub mod coords;
 pub mod error;
@@ -43,7 +25,7 @@ pub mod io;
 // Exposed because of input handlers in maplibre-winit
 pub mod map_schedule;
 pub mod platform;
-// Exposed because of camera
+// TODO: Exposed because of camera
 pub mod render;
 pub mod style;
 pub mod util;
@@ -54,209 +36,13 @@ pub mod schedule;
 // Exposed because of SharedThreadState
 pub mod stages;
 
+pub mod environment;
+
 // Used for benchmarking
 pub mod benchmarking;
 
 // Internal modules
 pub(crate) mod tessellation;
 
-pub mod environment;
-
+// Export tile format
 pub use geozero::mvt::tile;
-
-/// The [`Map`] defines the public interface of the map renderer.
-// DO NOT IMPLEMENT INTERNALS ON THIS STRUCT.
-pub struct Map<E: Environment> {
-    // FIXME (wasm-executor): Avoid RefCell, change ownership model!
-    map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>,
-    window: RefCell<Option<<E::MapWindowConfig as MapWindowConfig>::MapWindow>>,
-}
-
-impl<E: Environment> Map<E>
-where
-    <E::MapWindowConfig as MapWindowConfig>::MapWindow: EventLoop<E>,
-{
-    /// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
-    pub fn run(&self) {
-        self.run_with_optionally_max_frames(None);
-    }
-
-    /// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
-    ///
-    /// # Arguments
-    ///
-    /// * `max_frames` - Maximum number of frames per second.
-    pub fn run_with_max_frames(&self, max_frames: u64) {
-        self.run_with_optionally_max_frames(Some(max_frames));
-    }
-
-    /// Starts the MapState Runnable with the configured event loop.
-    ///
-    /// # Arguments
-    ///
-    /// * `max_frames` - Optional maximum number of frames per second.
-    pub fn run_with_optionally_max_frames(&self, max_frames: Option<u64>) {
-        self.window
-            .borrow_mut()
-            .take()
-            .unwrap() // FIXME (wasm-executor): Remove unwrap
-            .run(self.map_schedule.clone(), max_frames);
-    }
-
-    pub fn map_schedule(&self) -> Rc<RefCell<InteractiveMapSchedule<E>>> {
-        self.map_schedule.clone()
-    }
-
-    /*    pub fn map_schedule_mut(&mut self) -> &mut InteractiveMapSchedule<E> {
-        &mut self.map_schedule
-    }*/
-}
-
-/// Stores the map configuration before the map's state has been fully initialized.
-pub struct UninitializedMap<E: Environment> {
-    scheduler: E::Scheduler,
-    apc: E::AsyncProcedureCall,
-    http_client: E::HttpClient,
-    style: Style,
-
-    wgpu_settings: WgpuSettings,
-    renderer_settings: RendererSettings,
-    map_window_config: E::MapWindowConfig,
-}
-
-impl<E: Environment> UninitializedMap<E>
-where
-    <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
-{
-    /// Initializes the whole rendering pipeline for the given configuration.
-    /// Returns the initialized map, ready to be run.
-    pub async fn initialize(self) -> Map<E> {
-        let window = self.map_window_config.create();
-        let window_size = window.size();
-
-        #[cfg(target_os = "android")]
-        let renderer = None;
-        #[cfg(not(target_os = "android"))]
-        let renderer = Renderer::initialize(
-            &window,
-            self.wgpu_settings.clone(),
-            self.renderer_settings.clone(),
-        )
-        .await
-        .ok();
-        Map {
-            map_schedule: Rc::new(RefCell::new(InteractiveMapSchedule::new(
-                self.map_window_config,
-                window_size,
-                renderer,
-                self.scheduler,
-                self.apc,
-                self.http_client,
-                self.style,
-                self.wgpu_settings,
-                self.renderer_settings,
-            ))),
-            window: RefCell::new(Some(window)),
-        }
-    }
-}
-
-#[cfg(feature = "headless")]
-impl<E: Environment> UninitializedMap<E> {
-    pub async fn initialize_headless(self) -> headless::HeadlessMap<E> {
-        let window = self.map_window_config.create();
-        let window_size = window.size();
-
-        let renderer = Renderer::initialize_headless(
-            &window,
-            self.wgpu_settings.clone(),
-            self.renderer_settings.clone(),
-        )
-        .await
-        .expect("Failed to initialize renderer");
-        headless::HeadlessMap {
-            map_schedule: headless::HeadlessMapSchedule::new(
-                self.map_window_config,
-                window_size,
-                renderer,
-                self.scheduler,
-                self.http_client,
-                self.style,
-            ),
-            window,
-        }
-    }
-}
-
-pub struct MapBuilder<E: Environment> {
-    scheduler: Option<E::Scheduler>,
-    apc: Option<E::AsyncProcedureCall>,
-    http_client: Option<E::HttpClient>,
-    style: Option<Style>,
-
-    map_window_config: Option<E::MapWindowConfig>,
-    wgpu_settings: Option<WgpuSettings>,
-    renderer_settings: Option<RendererSettings>,
-}
-
-impl<E: Environment> MapBuilder<E> {
-    pub fn new() -> Self {
-        Self {
-            scheduler: None,
-            apc: None,
-            http_client: None,
-            style: None,
-            map_window_config: None,
-            wgpu_settings: None,
-            renderer_settings: None,
-        }
-    }
-
-    pub fn with_map_window_config(mut self, map_window_config: E::MapWindowConfig) -> Self {
-        self.map_window_config = Some(map_window_config);
-        self
-    }
-
-    pub fn with_renderer_settings(mut self, renderer_settings: RendererSettings) -> Self {
-        self.renderer_settings = Some(renderer_settings);
-        self
-    }
-
-    pub fn with_wgpu_settings(mut self, wgpu_settings: WgpuSettings) -> Self {
-        self.wgpu_settings = Some(wgpu_settings);
-        self
-    }
-
-    pub fn with_scheduler(mut self, scheduler: E::Scheduler) -> Self {
-        self.scheduler = Some(scheduler);
-        self
-    }
-
-    pub fn with_apc(mut self, apc: E::AsyncProcedureCall) -> Self {
-        self.apc = Some(apc);
-        self
-    }
-
-    pub fn with_http_client(mut self, http_client: E::HttpClient) -> Self {
-        self.http_client = Some(http_client);
-        self
-    }
-
-    pub fn with_style(mut self, style: Style) -> Self {
-        self.style = Some(style);
-        self
-    }
-
-    /// Builds the UninitializedMap with the given configuration.
-    pub fn build(self) -> UninitializedMap<E> {
-        UninitializedMap {
-            scheduler: self.scheduler.unwrap(),     // TODO: Remove unwrap
-            apc: self.apc.unwrap(),                 // TODO: Remove unwrap
-            http_client: self.http_client.unwrap(), // TODO: Remove unwrap
-            style: self.style.unwrap_or_default(),
-            wgpu_settings: self.wgpu_settings.unwrap_or_default(),
-            renderer_settings: self.renderer_settings.unwrap_or_default(),
-            map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
-        }
-    }
-}
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
new file mode 100644
index 00000000..3f7952fc
--- /dev/null
+++ b/maplibre/src/map.rs
@@ -0,0 +1,47 @@
+/// The [`Map`] defines the public interface of the map renderer.
+// DO NOT IMPLEMENT INTERNALS ON THIS STRUCT.
+pub struct Map<E: Environment> {
+    // FIXME (wasm-executor): Avoid RefCell, change ownership model!
+    map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>,
+    window: RefCell<Option<<E::MapWindowConfig as MapWindowConfig>::MapWindow>>,
+}
+
+impl<E: Environment> Map<E>
+where
+    <E::MapWindowConfig as MapWindowConfig>::MapWindow: EventLoop<E>,
+{
+    /// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
+    pub fn run(&self) {
+        self.run_with_optionally_max_frames(None);
+    }
+
+    /// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
+    ///
+    /// # Arguments
+    ///
+    /// * `max_frames` - Maximum number of frames per second.
+    pub fn run_with_max_frames(&self, max_frames: u64) {
+        self.run_with_optionally_max_frames(Some(max_frames));
+    }
+
+    /// Starts the MapState Runnable with the configured event loop.
+    ///
+    /// # Arguments
+    ///
+    /// * `max_frames` - Optional maximum number of frames per second.
+    pub fn run_with_optionally_max_frames(&self, max_frames: Option<u64>) {
+        self.window
+            .borrow_mut()
+            .take()
+            .unwrap() // FIXME (wasm-executor): Remove unwrap
+            .run(self.map_schedule.clone(), max_frames);
+    }
+
+    pub fn map_schedule(&self) -> Rc<RefCell<InteractiveMapSchedule<E>>> {
+        self.map_schedule.clone()
+    }
+
+    /*    pub fn map_schedule_mut(&mut self) -> &mut InteractiveMapSchedule<E> {
+        &mut self.map_schedule
+    }*/
+}
diff --git a/maplibre/src/map_schedule.rs b/maplibre/src/map_schedule.rs
index 9b9ab037..cffa2b53 100644
--- a/maplibre/src/map_schedule.rs
+++ b/maplibre/src/map_schedule.rs
@@ -1,5 +1,9 @@
 use std::{cell::RefCell, marker::PhantomData, mem, rc::Rc};
 
+use crate::environment::Environment;
+use crate::render::settings::{RendererSettings, WgpuSettings};
+use crate::render::Renderer;
+use crate::window::{HeadedMapWindow, MapWindowConfig, WindowSize};
 use crate::{
     context::{MapContext, ViewState},
     coords::{LatLon, WorldCoords, Zoom, TILE_SIZE},
@@ -13,8 +17,6 @@ use crate::{
     schedule::{Schedule, Stage},
     stages::register_stages,
     style::Style,
-    Environment, HeadedMapWindow, MapWindowConfig, Renderer, RendererSettings, WgpuSettings,
-    WindowSize,
 };
 
 /// Stores the state of the map, dispatches tile fetching and caching, tessellation and drawing.
diff --git a/maplibre/src/platform/noweb/http_client.rs b/maplibre/src/platform/noweb/http_client.rs
index 3db96ed3..374b1340 100644
--- a/maplibre/src/platform/noweb/http_client.rs
+++ b/maplibre/src/platform/noweb/http_client.rs
@@ -3,7 +3,8 @@ use reqwest::{Client, StatusCode};
 use reqwest_middleware::ClientWithMiddleware;
 use reqwest_middleware_cache::{managers::CACacheManager, Cache, CacheMode};
 
-use crate::{error::Error, HttpClient};
+use crate::error::Error;
+use crate::io::source_client::HttpClient;
 
 #[derive(Clone)]
 pub struct ReqwestHttpClient {
diff --git a/maplibre/src/platform/noweb/scheduler.rs b/maplibre/src/platform/noweb/scheduler.rs
index c404d292..a3a65c5b 100644
--- a/maplibre/src/platform/noweb/scheduler.rs
+++ b/maplibre/src/platform/noweb/scheduler.rs
@@ -1,6 +1,7 @@
 use std::future::Future;
 
-use crate::{error::Error, Scheduler};
+use crate::error::Error;
+use crate::io::scheduler::Scheduler;
 
 /// Multi-threading with Tokio.
 pub struct TokioScheduler;
diff --git a/maplibre/src/render/builder.rs b/maplibre/src/render/builder.rs
new file mode 100644
index 00000000..001f366b
--- /dev/null
+++ b/maplibre/src/render/builder.rs
@@ -0,0 +1,76 @@
+use crate::environment::Environment;
+use crate::render::settings::{RendererSettings, WgpuSettings};
+use crate::render::Renderer;
+use crate::style::Style;
+use crate::window::{HeadedMapWindow, MapWindow, MapWindowConfig};
+
+pub struct RenderBuilder {
+    wgpu_settings: Option<WgpuSettings>,
+    renderer_settings: Option<RendererSettings>,
+}
+
+impl RenderBuilder {
+    pub fn with_renderer_settings(mut self, renderer_settings: RendererSettings) -> Self {
+        self.renderer_settings = Some(renderer_settings);
+        self
+    }
+
+    pub fn with_wgpu_settings(mut self, wgpu_settings: WgpuSettings) -> Self {
+        self.wgpu_settings = Some(wgpu_settings);
+        self
+    }
+
+    pub fn build(self) -> UninitializedRenderer {
+        UninitializedRenderer {
+            wgpu_settings: self.wgpu_settings.unwrap_or_default(),
+            renderer_settings: self.renderer_settings.unwrap_or_default(),
+        }
+    }
+}
+
+pub struct UninitializedRenderer {
+    wgpu_settings: WgpuSettings,
+    renderer_settings: RendererSettings,
+}
+
+impl UninitializedRenderer {
+    /// Initializes the whole rendering pipeline for the given configuration.
+    /// Returns the initialized map, ready to be run.
+    pub async fn initialize<MWC: MapWindowConfig>(self, map_window_config: MWC) -> Option<Renderer>
+    where
+        MWC::MapWindow: MapWindow + HeadedMapWindow,
+    {
+        let window = map_window_config.create();
+
+        #[cfg(target_os = "android")]
+        let renderer = None;
+        #[cfg(not(target_os = "android"))]
+        let renderer = Renderer::initialize(
+            &window,
+            self.wgpu_settings.clone(),
+            self.renderer_settings.clone(),
+        )
+        .await
+        .ok();
+
+        renderer
+    }
+}
+
+#[cfg(feature = "headless")]
+impl UninitializedRenderer {
+    pub async fn initialize_headless<MWC: MapWindowConfig>(
+        self,
+        map_window_config: MWC,
+    ) -> Option<Renderer> {
+        let window = map_window_config.create();
+
+        Renderer::initialize_headless(
+            &window,
+            self.wgpu_settings.clone(),
+            self.renderer_settings.clone(),
+        )
+        .await
+        .ok()
+    }
+}
diff --git a/maplibre/src/render/mod.rs b/maplibre/src/render/mod.rs
index a5625460..b61ab2d0 100644
--- a/maplibre/src/render/mod.rs
+++ b/maplibre/src/render/mod.rs
@@ -32,7 +32,6 @@ use crate::{
         tile_view_pattern::{TileInView, TileShape, TileViewPattern},
     },
     tessellation::IndexDataType,
-    HeadedMapWindow, MapWindow,
 };
 
 pub mod graph;
@@ -49,6 +48,7 @@ mod tile_pipeline;
 mod tile_view_pattern;
 
 // Public API
+pub mod builder;
 pub mod camera;
 pub mod eventually;
 pub mod settings;
@@ -60,8 +60,9 @@ use crate::render::{
     graph::{EmptyNode, RenderGraph, RenderGraphError},
     main_pass::{MainPassDriverNode, MainPassNode},
 };
+use crate::window::{HeadedMapWindow, MapWindow};
 
-pub const INDEX_FORMAT: wgpu::IndexFormat = wgpu::IndexFormat::Uint32; // Must match IndexDataType
+const INDEX_FORMAT: wgpu::IndexFormat = wgpu::IndexFormat::Uint32; // Must match IndexDataType
 
 pub struct RenderState {
     render_target: Eventually<TextureView>,
@@ -408,6 +409,9 @@ impl Renderer {
 
 #[cfg(test)]
 mod tests {
+    use crate::render::settings::RendererSettings;
+    use crate::render::RenderState;
+    use crate::window::{MapWindow, MapWindowConfig, WindowSize};
     use crate::{MapWindow, MapWindowConfig, WindowSize};
 
     pub struct HeadlessMapWindowConfig {
diff --git a/maplibre/src/render/render_commands.rs b/maplibre/src/render/render_commands.rs
index 371d18f6..64254518 100644
--- a/maplibre/src/render/render_commands.rs
+++ b/maplibre/src/render/render_commands.rs
@@ -1,15 +1,13 @@
 //! Specifies the instructions which are going to be sent to the GPU. Render commands can be concatenated
 //! into a new render command which executes multiple instruction sets.
 
-use crate::{
-    render::{
-        eventually::Eventually::Initialized,
-        render_phase::{PhaseItem, RenderCommand, RenderCommandResult},
-        resource::{Globals, IndexEntry, TrackedRenderPass},
-        tile_view_pattern::{TileInView, TileShape},
-        INDEX_FORMAT,
-    },
-    RenderState,
+use crate::render::RenderState;
+use crate::render::{
+    eventually::Eventually::Initialized,
+    render_phase::{PhaseItem, RenderCommand, RenderCommandResult},
+    resource::{Globals, IndexEntry, TrackedRenderPass},
+    tile_view_pattern::{TileInView, TileShape},
+    INDEX_FORMAT,
 };
 
 impl PhaseItem for TileInView {
diff --git a/maplibre/src/render/render_phase/draw.rs b/maplibre/src/render/render_phase/draw.rs
index e5513f32..7bf2418a 100644
--- a/maplibre/src/render/render_phase/draw.rs
+++ b/maplibre/src/render/render_phase/draw.rs
@@ -1,4 +1,5 @@
-use crate::{render::resource::TrackedRenderPass, RenderState};
+use crate::render::resource::TrackedRenderPass;
+use crate::render::RenderState;
 
 /// A draw function which is used to draw a specific [`PhaseItem`].
 ///
diff --git a/maplibre/src/render/resource/surface.rs b/maplibre/src/render/resource/surface.rs
index 10fbb92e..11ab63c3 100644
--- a/maplibre/src/render/resource/surface.rs
+++ b/maplibre/src/render/resource/surface.rs
@@ -3,10 +3,10 @@
 
 use std::{mem::size_of, sync::Arc};
 
+use crate::window::{MapWindow, WindowSize};
 use crate::{
     render::{eventually::HasChanged, resource::texture::TextureView, settings::RendererSettings},
     window::HeadedMapWindow,
-    MapWindow, WindowSize,
 };
 
 pub struct BufferDimensions {
diff --git a/maplibre/src/render/stages/extract_stage.rs b/maplibre/src/render/stages/extract_stage.rs
index 54f050cf..5eafa9c8 100644
--- a/maplibre/src/render/stages/extract_stage.rs
+++ b/maplibre/src/render/stages/extract_stage.rs
@@ -1,8 +1,9 @@
 //! Extracts data from the current state.
 
+use crate::render::{RenderState, Renderer};
 use crate::{
     context::MapContext, coords::ViewRegion, render::eventually::Eventually::Initialized,
-    schedule::Stage, RenderState, Renderer,
+    schedule::Stage,
 };
 
 #[derive(Default)]
diff --git a/maplibre/src/render/stages/graph_runner_stage.rs b/maplibre/src/render/stages/graph_runner_stage.rs
index 7ff41023..27ebf8ea 100644
--- a/maplibre/src/render/stages/graph_runner_stage.rs
+++ b/maplibre/src/render/stages/graph_runner_stage.rs
@@ -2,13 +2,13 @@
 
 use log::error;
 
+use crate::render::Renderer;
 use crate::{
     context::MapContext,
     render::{
         eventually::Eventually::Initialized, graph::RenderGraph, graph_runner::RenderGraphRunner,
     },
     schedule::Stage,
-    Renderer,
 };
 
 /// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.
diff --git a/maplibre/src/render/stages/phase_sort_stage.rs b/maplibre/src/render/stages/phase_sort_stage.rs
index a84c7600..0a5e22e1 100644
--- a/maplibre/src/render/stages/phase_sort_stage.rs
+++ b/maplibre/src/render/stages/phase_sort_stage.rs
@@ -1,6 +1,7 @@
 //! Sorts items of the [RenderPhases](RenderPhase).
 
-use crate::{context::MapContext, render::render_phase::RenderPhase, schedule::Stage, Renderer};
+use crate::render::Renderer;
+use crate::{context::MapContext, render::render_phase::RenderPhase, schedule::Stage};
 
 #[derive(Default)]
 pub struct PhaseSortStage;
diff --git a/maplibre/src/render/stages/queue_stage.rs b/maplibre/src/render/stages/queue_stage.rs
index c583865b..583f0dc0 100644
--- a/maplibre/src/render/stages/queue_stage.rs
+++ b/maplibre/src/render/stages/queue_stage.rs
@@ -1,12 +1,12 @@
 //! Queues [PhaseItems](crate::render::render_phase::PhaseItem) for rendering.
 
+use crate::render::{RenderState, Renderer};
 use crate::{
     context::MapContext,
     render::{
         eventually::Eventually::Initialized, resource::IndexEntry, tile_view_pattern::TileInView,
     },
     schedule::Stage,
-    RenderState, Renderer,
 };
 
 #[derive(Default)]
diff --git a/maplibre/src/render/stages/resource_stage.rs b/maplibre/src/render/stages/resource_stage.rs
index 8aeccee1..aa562ec5 100644
--- a/maplibre/src/render/stages/resource_stage.rs
+++ b/maplibre/src/render/stages/resource_stage.rs
@@ -2,6 +2,7 @@
 
 use std::mem::size_of;
 
+use crate::render::Renderer;
 use crate::{
     context::MapContext,
     render::{
@@ -12,7 +13,6 @@ use crate::{
         tile_view_pattern::{TileViewPattern, DEFAULT_TILE_VIEW_SIZE},
     },
     schedule::Stage,
-    Renderer,
 };
 
 #[derive(Default)]
diff --git a/maplibre/src/render/stages/upload_stage.rs b/maplibre/src/render/stages/upload_stage.rs
index 376e0cd1..745a8d09 100644
--- a/maplibre/src/render/stages/upload_stage.rs
+++ b/maplibre/src/render/stages/upload_stage.rs
@@ -2,6 +2,8 @@
 
 use std::iter;
 
+use crate::render::{RenderState, Renderer};
+use crate::style::Style;
 use crate::{
     context::MapContext,
     coords::ViewRegion,
@@ -12,7 +14,6 @@ use crate::{
         shaders::{ShaderCamera, ShaderFeatureStyle, ShaderGlobals, ShaderLayerMetadata, Vec4f32},
     },
     schedule::Stage,
-    RenderState, Renderer, Style,
 };
 
 #[derive(Default)]
diff --git a/maplibre/src/stages/mod.rs b/maplibre/src/stages/mod.rs
index 2de4b96c..c40095ae 100644
--- a/maplibre/src/stages/mod.rs
+++ b/maplibre/src/stages/mod.rs
@@ -10,6 +10,8 @@ use std::{
 use geozero::{mvt::tile, GeozeroDatasource};
 use request_stage::RequestStage;
 
+use crate::environment::Environment;
+use crate::io::source_client::HttpClient;
 use crate::{
     coords::{WorldCoords, WorldTileCoords, Zoom, ZoomLevel},
     error::Error,
@@ -30,7 +32,6 @@ use crate::{
     schedule::Schedule,
     stages::populate_tile_store_stage::PopulateTileStore,
     tessellation::{IndexDataType, OverAlignedVertexBuffer},
-    Environment, HttpClient, Scheduler,
 };
 
 mod populate_tile_store_stage;
diff --git a/maplibre/src/stages/populate_tile_store_stage.rs b/maplibre/src/stages/populate_tile_store_stage.rs
index bfb01f64..2c492b9c 100644
--- a/maplibre/src/stages/populate_tile_store_stage.rs
+++ b/maplibre/src/stages/populate_tile_store_stage.rs
@@ -2,6 +2,7 @@
 
 use std::{borrow::BorrowMut, cell::RefCell, ops::Deref, rc::Rc};
 
+use crate::environment::Environment;
 use crate::{
     context::MapContext,
     io::{
@@ -10,7 +11,6 @@ use crate::{
         transferables::{TessellatedLayer, TileTessellated, UnavailableLayer},
     },
     schedule::Stage,
-    Environment,
 };
 
 pub struct PopulateTileStore<E: Environment> {
diff --git a/maplibre/src/stages/request_stage.rs b/maplibre/src/stages/request_stage.rs
index ccc26d7e..8899ab79 100644
--- a/maplibre/src/stages/request_stage.rs
+++ b/maplibre/src/stages/request_stage.rs
@@ -12,6 +12,8 @@ use std::{
     str::FromStr,
 };
 
+use crate::environment::Environment;
+use crate::style::Style;
 use crate::{
     context::MapContext,
     coords::{ViewRegion, WorldTileCoords, ZoomLevel},
@@ -27,7 +29,6 @@ use crate::{
     },
     schedule::Stage,
     stages::HeadedPipelineProcessor,
-    Environment, HttpClient, Scheduler, Style,
 };
 
 pub struct RequestStage<E: Environment> {
diff --git a/maplibre/src/window.rs b/maplibre/src/window.rs
index 175b35ea..4bf68471 100644
--- a/maplibre/src/window.rs
+++ b/maplibre/src/window.rs
@@ -2,10 +2,10 @@
 
 use std::{cell::RefCell, rc::Rc};
 
+use crate::environment::Environment;
+use crate::map_schedule::InteractiveMapSchedule;
 use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
 
-use crate::{Environment, HttpClient, InteractiveMapSchedule};
-
 /// Window of a certain [`WindowSize`]. This can either be a proper window or a headless one.
 pub trait MapWindow {
     fn size(&self) -> WindowSize;
diff --git a/web/Cargo.toml b/web/Cargo.toml
index 8c07c754..9b7bc245 100644
--- a/web/Cargo.toml
+++ b/web/Cargo.toml
@@ -19,7 +19,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 async-trait = "0.1.56"
-maplibre = { path = "../maplibre", features = ["no-thread-safe-futures"] }
+maplibre = { path = "../maplibre", default-features = false, features = [] }
 maplibre-winit = { path = "../maplibre-winit", version = "0.0.1"  }
 
 log = "0.4.17"

From 4879d9c0b4bf093bcdf3fbad2379090d51110d1c Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 25 Sep 2022 13:26:35 +0200
Subject: [PATCH 02/31] Refactor headless module, introduce world

---
 maplibre/src/context.rs                       |  91 +----
 maplibre/src/environment.rs                   |  30 +-
 maplibre/src/error.rs                         |  34 +-
 maplibre/src/headless.rs                      | 355 ------------------
 maplibre/src/headless/environment.rs          |  16 +
 maplibre/src/headless/graph_node.rs           |  63 ++++
 maplibre/src/headless/map.rs                  | 145 +++++++
 maplibre/src/headless/mod.rs                  |   6 +
 maplibre/src/headless/stage.rs                |  50 +++
 maplibre/src/headless/window.rs               |  23 ++
 maplibre/src/io/apc.rs                        |   7 +-
 maplibre/src/io/scheduler.rs                  |   2 +-
 maplibre/src/io/source_client.rs              |  16 +-
 maplibre/src/io/tile_repository.rs            |  22 +-
 maplibre/src/lib.rs                           |   1 +
 maplibre/src/map_schedule.rs                  |  53 ++-
 maplibre/src/platform/noweb/http_client.rs    |   3 +-
 maplibre/src/platform/noweb/scheduler.rs      |   3 +-
 maplibre/src/render/builder.rs                |  14 +-
 maplibre/src/render/error.rs                  |  36 ++
 maplibre/src/render/mod.rs                    |  20 +-
 maplibre/src/render/render_commands.rs        |   3 +-
 maplibre/src/render/render_phase/draw.rs      |   3 +-
 maplibre/src/render/resource/surface.rs       |   3 +-
 maplibre/src/render/stages/extract_stage.rs   |   8 +-
 .../src/render/stages/graph_runner_stage.rs   |   2 +-
 .../src/render/stages/phase_sort_stage.rs     |   7 +-
 maplibre/src/render/stages/queue_stage.rs     |   3 +-
 maplibre/src/render/stages/resource_stage.rs  |   2 +-
 maplibre/src/render/stages/upload_stage.rs    |  15 +-
 maplibre/src/stages/mod.rs                    |   5 +-
 .../src/stages/populate_tile_store_stage.rs   |   8 +-
 maplibre/src/stages/request_stage.rs          |  23 +-
 maplibre/src/window.rs                        |   4 +-
 maplibre/src/world.rs                         | 143 +++++++
 35 files changed, 626 insertions(+), 593 deletions(-)
 delete mode 100644 maplibre/src/headless.rs
 create mode 100644 maplibre/src/headless/environment.rs
 create mode 100644 maplibre/src/headless/graph_node.rs
 create mode 100644 maplibre/src/headless/map.rs
 create mode 100644 maplibre/src/headless/mod.rs
 create mode 100644 maplibre/src/headless/stage.rs
 create mode 100644 maplibre/src/headless/window.rs
 create mode 100644 maplibre/src/render/error.rs
 create mode 100644 maplibre/src/world.rs

diff --git a/maplibre/src/context.rs b/maplibre/src/context.rs
index 8b3f196c..cb970f2c 100644
--- a/maplibre/src/context.rs
+++ b/maplibre/src/context.rs
@@ -1,95 +1,8 @@
-use std::ops::Div;
-
-use cgmath::Angle;
-
-use crate::render::Renderer;
-use crate::style::Style;
-use crate::window::WindowSize;
-use crate::{
-    coords::{LatLon, ViewRegion, WorldCoords, Zoom, ZoomLevel, TILE_SIZE},
-    io::tile_repository::TileRepository,
-    render::camera::{Camera, Perspective, ViewProjection},
-    util::ChangeObserver,
-};
-
-/// Stores the camera configuration.
-pub struct ViewState {
-    pub zoom: ChangeObserver<Zoom>,
-    pub camera: ChangeObserver<Camera>,
-    pub perspective: Perspective,
-}
-
-impl ViewState {
-    pub fn new<P: Into<cgmath::Rad<f64>>>(
-        window_size: &WindowSize,
-        position: WorldCoords,
-        zoom: Zoom,
-        pitch: f64,
-        fovy: P,
-    ) -> Self {
-        let tile_center = TILE_SIZE / 2.0;
-        let fovy = fovy.into();
-        let height = tile_center / (fovy / 2.0).tan();
-
-        let camera = Camera::new(
-            (position.x, position.y, height),
-            cgmath::Deg(-90.0),
-            cgmath::Deg(pitch),
-            window_size.width(),
-            window_size.height(),
-        );
-
-        let perspective = Perspective::new(
-            window_size.width(),
-            window_size.height(),
-            cgmath::Deg(110.0),
-            // in tile.vertex.wgsl we are setting each layer's final `z` in ndc space to `z_index`.
-            // This means that regardless of the `znear` value all layers will be rendered as part
-            // of the near plane.
-            // These values have been selected experimentally:
-            // https://www.sjbaker.org/steve/omniv/love_your_z_buffer.html
-            1024.0,
-            2048.0,
-        );
-
-        Self {
-            zoom: ChangeObserver::new(zoom),
-            camera: ChangeObserver::new(camera),
-            perspective,
-        }
-    }
-
-    pub fn create_view_region(&self) -> Option<ViewRegion> {
-        self.camera
-            .view_region_bounding_box(&self.view_projection().invert())
-            .map(|bounding_box| {
-                ViewRegion::new(bounding_box, 0, 32, *self.zoom, self.visible_level())
-            })
-    }
-
-    pub fn view_projection(&self) -> ViewProjection {
-        self.camera.calc_view_proj(&self.perspective)
-    }
-
-    pub fn visible_level(&self) -> ZoomLevel {
-        self.zoom.level()
-    }
-
-    pub fn zoom(&self) -> Zoom {
-        *self.zoom
-    }
-
-    pub fn update_zoom(&mut self, new_zoom: Zoom) {
-        *self.zoom = new_zoom;
-        log::info!("zoom: {}", new_zoom);
-    }
-}
+use crate::{render::Renderer, style::Style, world::World};
 
 /// Stores the context of the map.
 pub struct MapContext {
-    pub view_state: ViewState,
     pub style: Style,
-
-    pub tile_repository: TileRepository,
+    pub world: World,
     pub renderer: Renderer,
 }
diff --git a/maplibre/src/environment.rs b/maplibre/src/environment.rs
index cc5ed371..c68b39e9 100644
--- a/maplibre/src/environment.rs
+++ b/maplibre/src/environment.rs
@@ -1,12 +1,14 @@
-use crate::io::scheduler::Scheduler;
-use crate::io::source_client::HttpClient;
-use crate::io::{
-    apc::AsyncProcedureCall,
-    transferables::{
-        DefaultTessellatedLayer, DefaultTileTessellated, DefaultUnavailableLayer, Transferables,
+use crate::{
+    io::{
+        apc::AsyncProcedureCall,
+        scheduler::Scheduler,
+        source_client::{HttpClient, HttpSourceClient, SourceClient},
+        transferables::{
+            DefaultTessellatedLayer, DefaultTileTessellated, DefaultUnavailableLayer, Transferables,
+        },
     },
+    window::MapWindowConfig,
 };
-use crate::window::MapWindowConfig;
 
 pub trait Environment: 'static {
     type MapWindowConfig: MapWindowConfig;
@@ -19,10 +21,10 @@ pub trait Environment: 'static {
 }
 
 pub struct Kernel<E: Environment> {
-    map_window_config: E::MapWindowConfig,
-    apc: E::AsyncProcedureCall,
-    scheduler: E::Scheduler,
-    http_client: E::HttpClient,
+    pub map_window_config: E::MapWindowConfig,
+    pub apc: E::AsyncProcedureCall,
+    pub scheduler: E::Scheduler,
+    pub source_client: SourceClient<E::HttpClient>,
 }
 
 pub struct KernelBuilder<E: Environment> {
@@ -64,9 +66,9 @@ impl<E: Environment> KernelBuilder<E> {
 
     pub fn build(self) -> Kernel<E> {
         Kernel {
-            scheduler: self.scheduler.unwrap(),     // TODO: Remove unwrap
-            apc: self.apc.unwrap(),                 // TODO: Remove unwrap
-            http_client: self.http_client.unwrap(), // TODO: Remove unwrap
+            scheduler: self.scheduler.unwrap(), // TODO: Remove unwrap
+            apc: self.apc.unwrap(),             // TODO: Remove unwrap
+            source_client: SourceClient::new(HttpSourceClient::new(self.http_client.unwrap())), // TODO: Remove unwrap
             map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
         }
     }
diff --git a/maplibre/src/error.rs b/maplibre/src/error.rs
index 8cdea512..4d5f7fbe 100644
--- a/maplibre/src/error.rs
+++ b/maplibre/src/error.rs
@@ -4,45 +4,17 @@ use std::{fmt, fmt::Formatter, sync::mpsc::SendError};
 
 use lyon::tessellation::TessellationError;
 
-#[derive(Debug)]
-pub enum RenderError {
-    Surface(wgpu::SurfaceError),
-}
-
-impl fmt::Display for RenderError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            RenderError::Surface(e) => write!(f, "{}", e),
-        }
-    }
-}
-
-impl RenderError {
-    pub fn should_exit(&self) -> bool {
-        match self {
-            RenderError::Surface(e) => match e {
-                wgpu::SurfaceError::OutOfMemory => true,
-                _ => false,
-            },
-        }
-    }
-}
+use crate::render::{error::RenderError, graph::RenderGraphError};
 
 /// Enumeration of errors which can happen during the operation of the library.
 #[derive(Debug)]
 pub enum Error {
-    Schedule,
+    Scheduler,
     Network(String),
     Tesselation(TessellationError),
     Render(RenderError),
 }
 
-impl From<wgpu::SurfaceError> for Error {
-    fn from(e: wgpu::SurfaceError) -> Self {
-        Error::Render(RenderError::Surface(e))
-    }
-}
-
 impl From<TessellationError> for Error {
     fn from(e: TessellationError) -> Self {
         Error::Tesselation(e)
@@ -51,6 +23,6 @@ impl From<TessellationError> for Error {
 
 impl<T> From<SendError<T>> for Error {
     fn from(_e: SendError<T>) -> Self {
-        Error::Schedule
+        Error::Scheduler
     }
 }
diff --git a/maplibre/src/headless.rs b/maplibre/src/headless.rs
deleted file mode 100644
index 98b20784..00000000
--- a/maplibre/src/headless.rs
+++ /dev/null
@@ -1,355 +0,0 @@
-use std::{
-    collections::HashSet,
-    fs::File,
-    future::Future,
-    io::Write,
-    iter,
-    marker::PhantomData,
-    ops::{Deref, Range},
-    sync::Arc,
-};
-
-use tokio::{runtime::Handle, task};
-use wgpu::{BufferAsyncError, BufferSlice};
-
-use crate::environment::Environment;
-use crate::io::scheduler::Scheduler;
-use crate::io::source_client::HttpClient;
-use crate::render::Renderer;
-use crate::style::Style;
-use crate::window::{MapWindow, MapWindowConfig, WindowSize};
-use crate::{
-    context::{MapContext, ViewState},
-    coords::{LatLon, ViewRegion, WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
-    error::Error,
-    headless::utils::HeadlessPipelineProcessor,
-    io::{
-        apc::{AsyncProcedureCall, SchedulerAsyncProcedureCall},
-        pipeline::{PipelineContext, Processable},
-        source_client::HttpSourceClient,
-        tile_pipelines::build_vector_tile_pipeline,
-        tile_repository::{StoredLayer, TileRepository},
-        transferables::{DefaultTransferables, Transferables},
-        TileRequest,
-    },
-    render::{
-        camera::ViewProjection,
-        create_default_render_graph, draw_graph,
-        eventually::Eventually,
-        graph::{Node, NodeRunError, RenderContext, RenderGraphContext, SlotInfo},
-        register_default_render_stages,
-        resource::{BufferDimensions, BufferedTextureHead, Head, IndexEntry, TrackedRenderPass},
-        stages::RenderStageLabel,
-        RenderState,
-    },
-    schedule::{Schedule, Stage},
-};
-
-pub struct HeadlessMapWindowConfig {
-    pub size: WindowSize,
-}
-
-impl MapWindowConfig for HeadlessMapWindowConfig {
-    type MapWindow = HeadlessMapWindow;
-
-    fn create(&self) -> Self::MapWindow {
-        Self::MapWindow { size: self.size }
-    }
-}
-
-pub struct HeadlessMapWindow {
-    size: WindowSize,
-}
-
-impl MapWindow for HeadlessMapWindow {
-    fn size(&self) -> WindowSize {
-        self.size
-    }
-}
-
-pub struct HeadlessEnvironment<
-    S: Scheduler,
-    HC: HttpClient,
-    T: Transferables,
-    APC: AsyncProcedureCall<T, HC>,
-> {
-    phantom_s: PhantomData<S>,
-    phantom_hc: PhantomData<HC>,
-    phantom_t: PhantomData<T>,
-    phantom_apc: PhantomData<APC>,
-}
-
-impl<S: Scheduler, HC: HttpClient, T: Transferables, APC: AsyncProcedureCall<T, HC>> Environment
-    for HeadlessEnvironment<S, HC, T, APC>
-{
-    type MapWindowConfig = HeadlessMapWindowConfig;
-    type AsyncProcedureCall = APC;
-    type Scheduler = S;
-    type HttpClient = HC;
-    type Transferables = T;
-}
-
-pub struct HeadlessMap<E: Environment> {
-    pub map_schedule: HeadlessMapSchedule<E>,
-    pub window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
-}
-
-impl<E: Environment> HeadlessMap<E> {
-    pub fn map_schedule_mut(&mut self) -> &mut HeadlessMapSchedule<E> {
-        &mut self.map_schedule
-    }
-}
-
-/// Stores the state of the map, dispatches tile fetching and caching, tessellation and drawing.
-pub struct HeadlessMapSchedule<E: Environment> {
-    map_window_config: E::MapWindowConfig,
-
-    pub map_context: MapContext,
-
-    schedule: Schedule,
-    scheduler: E::Scheduler,
-    http_client: E::HttpClient,
-}
-
-impl<E: Environment> HeadlessMapSchedule<E> {
-    pub fn new(
-        map_window_config: E::MapWindowConfig,
-        window_size: WindowSize,
-        renderer: Renderer,
-        scheduler: E::Scheduler,
-        http_client: E::HttpClient,
-        style: Style,
-    ) -> Self {
-        let view_state = ViewState::new(
-            &window_size,
-            WorldCoords::from((TILE_SIZE / 2., TILE_SIZE / 2.)),
-            Zoom::default(),
-            0.0,
-            cgmath::Deg(110.0),
-        );
-        let tile_repository = TileRepository::new();
-        let mut schedule = Schedule::default();
-
-        let mut graph = create_default_render_graph().unwrap(); // TODO: remove unwrap
-        let draw_graph = graph.get_sub_graph_mut(draw_graph::NAME).unwrap(); // TODO: remove unwrap
-        draw_graph.add_node(draw_graph::node::COPY, CopySurfaceBufferNode::default());
-        draw_graph
-            .add_node_edge(draw_graph::node::MAIN_PASS, draw_graph::node::COPY)
-            .unwrap(); // TODO: remove unwrap
-
-        register_default_render_stages(graph, &mut schedule);
-
-        schedule.add_stage(
-            RenderStageLabel::Cleanup,
-            WriteSurfaceBufferStage::default(),
-        );
-
-        Self {
-            map_window_config,
-            map_context: MapContext {
-                view_state,
-                style,
-                tile_repository,
-                renderer,
-            },
-            schedule,
-            scheduler,
-            http_client,
-        }
-    }
-
-    #[tracing::instrument(name = "update_and_redraw", skip_all)]
-    pub fn update_and_redraw(&mut self) -> Result<(), Error> {
-        self.schedule.run(&mut self.map_context);
-        Ok(())
-    }
-
-    pub fn schedule(&self) -> &Schedule {
-        &self.schedule
-    }
-    pub fn scheduler(&self) -> &E::Scheduler {
-        &self.scheduler
-    }
-    pub fn http_client(&self) -> &E::HttpClient {
-        &self.http_client
-    }
-
-    pub async fn fetch_process(&mut self, coords: &WorldTileCoords) -> Option<()> {
-        let source_layers: HashSet<String> = self
-            .map_context
-            .style
-            .layers
-            .iter()
-            .filter_map(|layer| layer.source_layer.clone())
-            .collect();
-
-        let http_source_client: HttpSourceClient<E::HttpClient> =
-            HttpSourceClient::new(self.http_client.clone());
-
-        let data = http_source_client
-            .fetch(&coords)
-            .await
-            .unwrap() // TODO: remove unwrap
-            .into_boxed_slice();
-
-        let mut pipeline_context = PipelineContext::new(HeadlessPipelineProcessor::default());
-        let pipeline = build_vector_tile_pipeline();
-
-        let request = TileRequest {
-            coords: WorldTileCoords::default(),
-            layers: source_layers,
-        };
-
-        pipeline.process((request, data), &mut pipeline_context);
-
-        let mut processor = pipeline_context
-            .take_processor::<HeadlessPipelineProcessor>()
-            .unwrap(); // TODO: remove unwrap
-
-        if let Eventually::Initialized(pool) = self.map_context.renderer.state.buffer_pool_mut() {
-            pool.clear();
-        }
-
-        self.map_context.tile_repository.clear();
-
-        while let Some(layer) = processor.layers.pop() {
-            self.map_context
-                .tile_repository
-                .create_tile(&layer.get_coords());
-            self.map_context
-                .tile_repository
-                .put_tessellated_layer(layer);
-        }
-
-        Some(())
-    }
-}
-
-/// Node which copies the contents of the GPU-side texture in [`BufferedTextureHead`] to an
-/// unmapped GPU-side buffer. This buffer will be mapped in
-/// [`crate::render::stages::write_surface_buffer_stage::WriteSurfaceBufferStage`].
-#[derive(Default)]
-pub struct CopySurfaceBufferNode {}
-
-impl CopySurfaceBufferNode {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Node for CopySurfaceBufferNode {
-    fn input(&self) -> Vec<SlotInfo> {
-        vec![]
-    }
-
-    fn update(&mut self, _state: &mut RenderState) {}
-
-    fn run(
-        &self,
-        _graph: &mut RenderGraphContext,
-        RenderContext {
-            command_encoder, ..
-        }: &mut RenderContext,
-        state: &RenderState,
-    ) -> Result<(), NodeRunError> {
-        let surface = state.surface();
-        match surface.head() {
-            Head::Headed(_) => {}
-            Head::Headless(buffered_texture) => {
-                let size = surface.size();
-                command_encoder.copy_texture_to_buffer(
-                    buffered_texture.texture.as_image_copy(),
-                    wgpu::ImageCopyBuffer {
-                        buffer: &buffered_texture.output_buffer,
-                        layout: wgpu::ImageDataLayout {
-                            offset: 0,
-                            bytes_per_row: Some(
-                                std::num::NonZeroU32::new(
-                                    buffered_texture.buffer_dimensions.padded_bytes_per_row as u32,
-                                )
-                                .unwrap(), // TODO: remove unwrap
-                            ),
-                            rows_per_image: None,
-                        },
-                    },
-                    wgpu::Extent3d {
-                        width: size.width() as u32,
-                        height: size.height() as u32,
-                        depth_or_array_layers: 1,
-                    },
-                );
-            }
-        }
-
-        Ok(())
-    }
-}
-
-/// Stage which writes the current contents of the GPU/CPU buffer in [`BufferedTextureHead`]
-/// to disk as PNG.
-#[derive(Default)]
-pub struct WriteSurfaceBufferStage {
-    frame: u64,
-}
-
-impl Stage for WriteSurfaceBufferStage {
-    fn run(
-        &mut self,
-        MapContext {
-            renderer: Renderer { state, device, .. },
-            ..
-        }: &mut MapContext,
-    ) {
-        let surface = state.surface();
-        match surface.head() {
-            Head::Headed(_) => {}
-            Head::Headless(buffered_texture) => {
-                let buffered_texture: Arc<BufferedTextureHead> = buffered_texture.clone();
-
-                let device = device.clone();
-                let current_frame = self.frame;
-
-                task::block_in_place(|| {
-                    Handle::current().block_on(async {
-                        buffered_texture
-                            .create_png(&device, format!("frame_{}.png", current_frame).as_str())
-                            .await;
-                    })
-                });
-
-                self.frame += 1;
-            }
-        }
-    }
-}
-
-pub mod utils {
-    use crate::{
-        coords::WorldTileCoords,
-        io::{pipeline::PipelineProcessor, tile_repository::StoredLayer, RawLayer},
-        render::ShaderVertex,
-        tessellation::{IndexDataType, OverAlignedVertexBuffer},
-    };
-
-    #[derive(Default)]
-    pub struct HeadlessPipelineProcessor {
-        pub layers: Vec<StoredLayer>,
-    }
-
-    impl PipelineProcessor for HeadlessPipelineProcessor {
-        fn layer_tesselation_finished(
-            &mut self,
-            coords: &WorldTileCoords,
-            buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
-            feature_indices: Vec<u32>,
-            layer_data: RawLayer,
-        ) {
-            self.layers.push(StoredLayer::TessellatedLayer {
-                coords: *coords,
-                layer_name: layer_data.name,
-                buffer,
-                feature_indices,
-            })
-        }
-    }
-}
diff --git a/maplibre/src/headless/environment.rs b/maplibre/src/headless/environment.rs
new file mode 100644
index 00000000..6efb78a8
--- /dev/null
+++ b/maplibre/src/headless/environment.rs
@@ -0,0 +1,16 @@
+use crate::environment::Environment;
+use crate::headless::window::HeadlessMapWindowConfig;
+use crate::io::apc::SchedulerAsyncProcedureCall;
+use crate::io::transferables::DefaultTransferables;
+use crate::platform::http_client::ReqwestHttpClient;
+use crate::platform::scheduler::TokioScheduler;
+
+pub struct HeadlessEnvironment;
+
+impl Environment for HeadlessEnvironment {
+    type MapWindowConfig = HeadlessMapWindowConfig;
+    type AsyncProcedureCall = SchedulerAsyncProcedureCall<Self::HttpClient, Self::Scheduler>;
+    type Scheduler = TokioScheduler;
+    type HttpClient = ReqwestHttpClient;
+    type Transferables = DefaultTransferables;
+}
diff --git a/maplibre/src/headless/graph_node.rs b/maplibre/src/headless/graph_node.rs
new file mode 100644
index 00000000..b050bf30
--- /dev/null
+++ b/maplibre/src/headless/graph_node.rs
@@ -0,0 +1,63 @@
+use crate::render::graph::{Node, NodeRunError, RenderContext, RenderGraphContext, SlotInfo};
+use crate::render::resource::Head;
+use crate::render::RenderState;
+
+/// Node which copies the contents of the GPU-side texture in [`BufferedTextureHead`] to an
+/// unmapped GPU-side buffer. This buffer will be mapped in
+/// [`crate::render::stages::write_surface_buffer_stage::WriteSurfaceBufferStage`].
+#[derive(Default)]
+pub struct CopySurfaceBufferNode {}
+
+impl CopySurfaceBufferNode {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Node for CopySurfaceBufferNode {
+    fn input(&self) -> Vec<SlotInfo> {
+        vec![]
+    }
+
+    fn update(&mut self, _state: &mut RenderState) {}
+
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        RenderContext {
+            command_encoder, ..
+        }: &mut RenderContext,
+        state: &RenderState,
+    ) -> Result<(), NodeRunError> {
+        let surface = state.surface();
+        match surface.head() {
+            Head::Headed(_) => {}
+            Head::Headless(buffered_texture) => {
+                let size = surface.size();
+                command_encoder.copy_texture_to_buffer(
+                    buffered_texture.texture.as_image_copy(),
+                    wgpu::ImageCopyBuffer {
+                        buffer: &buffered_texture.output_buffer,
+                        layout: wgpu::ImageDataLayout {
+                            offset: 0,
+                            bytes_per_row: Some(
+                                std::num::NonZeroU32::new(
+                                    buffered_texture.buffer_dimensions.padded_bytes_per_row as u32,
+                                )
+                                .unwrap(), // TODO: remove unwrap
+                            ),
+                            rows_per_image: None,
+                        },
+                    },
+                    wgpu::Extent3d {
+                        width: size.width() as u32,
+                        height: size.height() as u32,
+                        depth_or_array_layers: 1,
+                    },
+                );
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
new file mode 100644
index 00000000..54deef43
--- /dev/null
+++ b/maplibre/src/headless/map.rs
@@ -0,0 +1,145 @@
+use crate::io::pipeline::Processable;
+use crate::{
+    context::MapContext,
+    coords::{WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
+    environment::Kernel,
+    error::Error,
+    headless::{
+        environment::HeadlessEnvironment, graph_node::CopySurfaceBufferNode,
+        stage::WriteSurfaceBufferStage,
+    },
+    io::{
+        pipeline::{PipelineContext, PipelineProcessor},
+        tile_pipelines::build_vector_tile_pipeline,
+        tile_repository::{StoredLayer, StoredTile, TileStatus},
+        RawLayer, TileRequest,
+    },
+    render::{
+        create_default_render_graph, draw_graph, error::RenderError, eventually::Eventually,
+        register_default_render_stages, resource::Head, stages::RenderStageLabel, Renderer,
+        ShaderVertex,
+    },
+    schedule::{Schedule, Stage},
+    style::Style,
+    tessellation::{IndexDataType, OverAlignedVertexBuffer},
+    window::WindowSize,
+    world::World,
+};
+use std::collections::HashSet;
+
+pub struct HeadlessMap {
+    window_size: WindowSize,
+    kernel: Kernel<HeadlessEnvironment>,
+    map_context: MapContext,
+    schedule: Schedule,
+}
+
+impl HeadlessMap {
+    pub fn new(
+        style: Style,
+        window_size: WindowSize,
+        renderer: Renderer,
+        kernel: Kernel<HeadlessEnvironment>,
+    ) -> Result<Self, Error> {
+        let world = World::new(
+            window_size,
+            WorldCoords::from((TILE_SIZE / 2., TILE_SIZE / 2.)),
+            Zoom::default(),
+            cgmath::Deg(110.0),
+        );
+
+        let mut schedule = Schedule::default();
+
+        let mut graph = create_default_render_graph()?;
+        let draw_graph = graph
+            .get_sub_graph_mut(draw_graph::NAME)
+            .expect("Subgraph does not exist");
+        draw_graph.add_node(draw_graph::node::COPY, CopySurfaceBufferNode::default());
+        draw_graph
+            .add_node_edge(draw_graph::node::MAIN_PASS, draw_graph::node::COPY)
+            .unwrap(); // TODO: remove unwrap
+
+        register_default_render_stages(graph, &mut schedule);
+
+        schedule.add_stage(
+            RenderStageLabel::Cleanup,
+            WriteSurfaceBufferStage::default(),
+        );
+
+        Ok(Self {
+            window_size,
+            kernel,
+            map_context: MapContext {
+                style,
+                world,
+                renderer,
+            },
+            schedule,
+        })
+    }
+
+    pub async fn render_tile(&mut self, tile: StoredTile) -> Result<(), Error> {
+        let context = &mut self.map_context;
+
+        if let Eventually::Initialized(pool) = context.renderer.state.buffer_pool_mut() {
+            pool.clear();
+        }
+
+        context.world.tile_repository.put_tile(tile);
+
+        self.schedule.run(&mut self.map_context);
+        Ok(())
+    }
+
+    pub async fn fetch_tile(
+        &self,
+        coords: WorldTileCoords,
+        source_layers: HashSet<String>,
+    ) -> Result<StoredTile, Error> {
+        let source_client = &self.kernel.source_client;
+
+        let data = source_client.fetch(&coords).await?.into_boxed_slice();
+
+        let mut pipeline_context = PipelineContext::new(HeadlessPipelineProcessor::default());
+        let pipeline = build_vector_tile_pipeline();
+
+        pipeline.process(
+            (
+                TileRequest {
+                    coords: WorldTileCoords::default(),
+                    layers: source_layers,
+                },
+                data,
+            ),
+            &mut pipeline_context,
+        );
+
+        let mut processor = pipeline_context
+            .take_processor::<HeadlessPipelineProcessor>()
+            .expect("Unable to get processor");
+
+        Ok(StoredTile::success(coords, processor.layers))
+    }
+}
+
+#[derive(Default)]
+pub struct HeadlessPipelineProcessor {
+    pub layers: Vec<StoredLayer>,
+}
+
+impl PipelineProcessor for HeadlessPipelineProcessor {
+    fn layer_tesselation_finished(
+        &mut self,
+        coords: &WorldTileCoords,
+        buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
+        feature_indices: Vec<u32>,
+        layer_data: RawLayer,
+    ) {
+        self.layers.push(StoredLayer::TessellatedLayer {
+            coords: *coords,
+            layer_name: layer_data.name,
+            buffer,
+            feature_indices,
+        })
+    }
+}
diff --git a/maplibre/src/headless/mod.rs b/maplibre/src/headless/mod.rs
new file mode 100644
index 00000000..24362188
--- /dev/null
+++ b/maplibre/src/headless/mod.rs
@@ -0,0 +1,6 @@
+mod environment;
+mod graph_node;
+mod stage;
+mod window;
+
+pub mod map;
diff --git a/maplibre/src/headless/stage.rs b/maplibre/src/headless/stage.rs
new file mode 100644
index 00000000..c1a56ec0
--- /dev/null
+++ b/maplibre/src/headless/stage.rs
@@ -0,0 +1,50 @@
+use std::sync::Arc;
+
+use tokio::{runtime::Handle, task};
+
+use crate::{
+    context::MapContext,
+    render::{
+        resource::{BufferedTextureHead, Head},
+        Renderer,
+    },
+    schedule::Stage,
+};
+
+/// Stage which writes the current contents of the GPU/CPU buffer in [`BufferedTextureHead`]
+/// to disk as PNG.
+#[derive(Default)]
+pub struct WriteSurfaceBufferStage {
+    frame: u64,
+}
+
+impl Stage for WriteSurfaceBufferStage {
+    fn run(
+        &mut self,
+        MapContext {
+            renderer: Renderer { state, device, .. },
+            ..
+        }: &mut MapContext,
+    ) {
+        let surface = state.surface();
+        match surface.head() {
+            Head::Headed(_) => {}
+            Head::Headless(buffered_texture) => {
+                let buffered_texture: Arc<BufferedTextureHead> = buffered_texture.clone();
+
+                let device = device.clone();
+                let current_frame = self.frame;
+
+                task::block_in_place(|| {
+                    Handle::current().block_on(async {
+                        buffered_texture
+                            .create_png(&device, format!("frame_{}.png", current_frame).as_str())
+                            .await;
+                    })
+                });
+
+                self.frame += 1;
+            }
+        }
+    }
+}
diff --git a/maplibre/src/headless/window.rs b/maplibre/src/headless/window.rs
new file mode 100644
index 00000000..7faf5991
--- /dev/null
+++ b/maplibre/src/headless/window.rs
@@ -0,0 +1,23 @@
+use crate::window::{MapWindow, MapWindowConfig, WindowSize};
+
+pub struct HeadlessMapWindowConfig {
+    pub size: WindowSize,
+}
+
+impl MapWindowConfig for HeadlessMapWindowConfig {
+    type MapWindow = HeadlessMapWindow;
+
+    fn create(&self) -> Self::MapWindow {
+        Self::MapWindow { size: self.size }
+    }
+}
+
+pub struct HeadlessMapWindow {
+    size: WindowSize,
+}
+
+impl MapWindow for HeadlessMapWindow {
+    fn size(&self) -> WindowSize {
+        self.size
+    }
+}
diff --git a/maplibre/src/io/apc.rs b/maplibre/src/io/apc.rs
index 057153ff..de44408f 100644
--- a/maplibre/src/io/apc.rs
+++ b/maplibre/src/io/apc.rs
@@ -10,12 +10,11 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
-use crate::io::scheduler::Scheduler;
-use crate::io::source_client::HttpClient;
 use crate::{
     coords::WorldTileCoords,
     io::{
-        source_client::{HttpSourceClient, SourceClient},
+        scheduler::Scheduler,
+        source_client::{HttpClient, HttpSourceClient, SourceClient},
         transferables::{DefaultTransferables, Transferables},
         TileRequest,
     },
@@ -112,7 +111,7 @@ impl<HC: HttpClient, S: Scheduler> AsyncProcedureCall<DefaultTransferables, HC>
                     input,
                     SchedulerContext {
                         sender,
-                        source_client: SourceClient::Http(HttpSourceClient::new(client)),
+                        source_client: SourceClient::new(HttpSourceClient::new(client)),
                     },
                 )
                 .await;
diff --git a/maplibre/src/io/scheduler.rs b/maplibre/src/io/scheduler.rs
index 912436d3..67e4cb7b 100644
--- a/maplibre/src/io/scheduler.rs
+++ b/maplibre/src/io/scheduler.rs
@@ -31,6 +31,6 @@ impl Scheduler for NopScheduler {
     where
         T: Future<Output = ()> + 'static,
     {
-        Err(Error::Schedule)
+        Err(Error::Scheduler)
     }
 }
diff --git a/maplibre/src/io/source_client.rs b/maplibre/src/io/source_client.rs
index ba432d09..54de0593 100644
--- a/maplibre/src/io/source_client.rs
+++ b/maplibre/src/io/source_client.rs
@@ -32,25 +32,23 @@ where
 /// Defines the different types of HTTP clients such as basic HTTP and Mbtiles.
 /// More types might be coming such as S3 and other cloud http clients.
 #[derive(Clone)]
-pub enum SourceClient<HC>
+pub struct SourceClient<HC>
 where
     HC: HttpClient,
 {
-    Http(HttpSourceClient<HC>),
-    Mbtiles {
-        // TODO
-    },
+    http: HttpSourceClient<HC>, // TODO: mbtiles: Mbtiles
 }
 
 impl<HC> SourceClient<HC>
 where
     HC: HttpClient,
 {
+    pub fn new(http: HttpSourceClient<HC>) -> Self {
+        Self { http }
+    }
+
     pub async fn fetch(&self, coords: &WorldTileCoords) -> Result<Vec<u8>, Error> {
-        match self {
-            SourceClient::Http(client) => client.fetch(coords).await,
-            SourceClient::Mbtiles { .. } => unimplemented!(),
-        }
+        self.http.fetch(coords).await
     }
 }
 
diff --git a/maplibre/src/io/tile_repository.rs b/maplibre/src/io/tile_repository.rs
index d673ce17..714d73a8 100644
--- a/maplibre/src/io/tile_repository.rs
+++ b/maplibre/src/io/tile_repository.rs
@@ -50,17 +50,27 @@ pub enum TileStatus {
 
 /// Stores multiple [StoredLayers](StoredLayer).
 pub struct StoredTile {
+    coords: WorldTileCoords,
     layers: Vec<StoredLayer>,
     status: TileStatus,
 }
 
 impl StoredTile {
-    pub fn new() -> Self {
+    pub fn new(coords: WorldTileCoords) -> Self {
         Self {
+            coords,
             layers: vec![],
             status: TileStatus::Pending,
         }
     }
+
+    pub fn success(coords: WorldTileCoords, layers: Vec<StoredLayer>) -> Self {
+        Self {
+            coords,
+            layers,
+            status: TileStatus::Success,
+        }
+    }
 }
 
 /// Stores and provides access to a quad tree of cached tiles with world tile coords.
@@ -102,6 +112,12 @@ impl TileRepository {
         }
     }
 
+    pub fn put_tile(&mut self, tile: StoredTile) {
+        if let Some(key) = tile.coords.build_quad_key() {
+            self.tree.insert(key, tile);
+        }
+    }
+
     /// Returns the list of tessellated layers at the given world tile coords. None if tile is
     /// missing from the cache.
     pub fn iter_tessellated_layers_at(
@@ -115,11 +131,11 @@ impl TileRepository {
     }
 
     /// Create a new tile.
-    pub fn create_tile(&mut self, coords: &WorldTileCoords) -> bool {
+    pub fn create_tile(&mut self, coords: WorldTileCoords) -> bool {
         if let Some(entry) = coords.build_quad_key().map(|key| self.tree.entry(key)) {
             match entry {
                 btree_map::Entry::Vacant(entry) => {
-                    entry.insert(StoredTile::new());
+                    entry.insert(StoredTile::new(coords));
                 }
                 _ => {}
             }
diff --git a/maplibre/src/lib.rs b/maplibre/src/lib.rs
index 9e8ac6db..50774a5d 100644
--- a/maplibre/src/lib.rs
+++ b/maplibre/src/lib.rs
@@ -43,6 +43,7 @@ pub mod benchmarking;
 
 // Internal modules
 pub(crate) mod tessellation;
+mod world;
 
 // Export tile format
 pub use geozero::mvt::tile;
diff --git a/maplibre/src/map_schedule.rs b/maplibre/src/map_schedule.rs
index cffa2b53..c191cd35 100644
--- a/maplibre/src/map_schedule.rs
+++ b/maplibre/src/map_schedule.rs
@@ -1,22 +1,25 @@
 use std::{cell::RefCell, marker::PhantomData, mem, rc::Rc};
 
-use crate::environment::Environment;
-use crate::render::settings::{RendererSettings, WgpuSettings};
-use crate::render::Renderer;
-use crate::window::{HeadedMapWindow, MapWindowConfig, WindowSize};
 use crate::{
-    context::{MapContext, ViewState},
+    context::MapContext,
     coords::{LatLon, WorldCoords, Zoom, TILE_SIZE},
+    environment::Environment,
     error::Error,
     io::{
         scheduler::Scheduler,
         source_client::{HttpClient, HttpSourceClient},
         tile_repository::TileRepository,
     },
-    render::{create_default_render_graph, register_default_render_stages},
+    render::{
+        create_default_render_graph, register_default_render_stages,
+        settings::{RendererSettings, WgpuSettings},
+        Renderer,
+    },
     schedule::{Schedule, Stage},
     stages::register_stages,
     style::Style,
+    window::{HeadedMapWindow, MapWindowConfig, WindowSize},
+    world::{ViewState, World},
 };
 
 /// Stores the state of the map, dispatches tile fetching and caching, tessellation and drawing.
@@ -34,26 +37,15 @@ pub struct InteractiveMapSchedule<E: Environment> {
 }
 
 impl<E: Environment> InteractiveMapSchedule<E> {
-    pub fn new(
-        map_window_config: E::MapWindowConfig,
-        window_size: WindowSize,
-        renderer: Option<Renderer>,
-        scheduler: E::Scheduler, // TODO: unused
-        apc: E::AsyncProcedureCall,
-        http_client: E::HttpClient,
-        style: Style,
-        wgpu_settings: WgpuSettings,
-        renderer_settings: RendererSettings,
-    ) -> Self {
-        let zoom = style.zoom.map(|zoom| Zoom::new(zoom)).unwrap_or_default();
-        let position = style
-            .center
-            .map(|center| WorldCoords::from_lat_lon(LatLon::new(center[0], center[1]), zoom))
-            .unwrap_or_default();
-        let pitch = style.pitch.unwrap_or_default();
-        let view_state = ViewState::new(&window_size, position, zoom, pitch, cgmath::Deg(110.0));
+    pub fn new(window_size: WindowSize, renderer: Option<Renderer>, style: Style) -> Self {
+        let center = style.center.unwrap_or_default();
+        let world = World::new_at(
+            window_size,
+            LatLon::new(center[0], center[1]),
+            style.zoom.map(|zoom| Zoom::new(zoom)).unwrap_or_default(),
+            cgmath::Deg::<f64>(style.pitch.unwrap_or_default()),
+        );
 
-        let tile_repository = TileRepository::new();
         let mut schedule = Schedule::default();
 
         let apc = Rc::new(RefCell::new(apc));
@@ -70,16 +62,14 @@ impl<E: Environment> InteractiveMapSchedule<E> {
             map_window_config,
             map_context: match renderer {
                 None => EventuallyMapContext::Premature(PrematureMapContext {
-                    view_state,
+                    world,
                     style,
-                    tile_repository,
                     wgpu_settings,
                     renderer_settings,
                 }),
                 Some(renderer) => EventuallyMapContext::Full(MapContext {
-                    view_state,
+                    world,
                     style,
-                    tile_repository,
                     renderer,
                 }),
             },
@@ -169,10 +159,9 @@ where
 }
 
 pub struct PrematureMapContext {
-    view_state: ViewState,
-    style: Style,
+    world: World,
 
-    tile_repository: TileRepository,
+    style: Style,
 
     wgpu_settings: WgpuSettings,
     renderer_settings: RendererSettings,
diff --git a/maplibre/src/platform/noweb/http_client.rs b/maplibre/src/platform/noweb/http_client.rs
index 374b1340..5ebd8153 100644
--- a/maplibre/src/platform/noweb/http_client.rs
+++ b/maplibre/src/platform/noweb/http_client.rs
@@ -3,8 +3,7 @@ use reqwest::{Client, StatusCode};
 use reqwest_middleware::ClientWithMiddleware;
 use reqwest_middleware_cache::{managers::CACacheManager, Cache, CacheMode};
 
-use crate::error::Error;
-use crate::io::source_client::HttpClient;
+use crate::{error::Error, io::source_client::HttpClient};
 
 #[derive(Clone)]
 pub struct ReqwestHttpClient {
diff --git a/maplibre/src/platform/noweb/scheduler.rs b/maplibre/src/platform/noweb/scheduler.rs
index a3a65c5b..427ed927 100644
--- a/maplibre/src/platform/noweb/scheduler.rs
+++ b/maplibre/src/platform/noweb/scheduler.rs
@@ -1,7 +1,6 @@
 use std::future::Future;
 
-use crate::error::Error;
-use crate::io::scheduler::Scheduler;
+use crate::{error::Error, io::scheduler::Scheduler};
 
 /// Multi-threading with Tokio.
 pub struct TokioScheduler;
diff --git a/maplibre/src/render/builder.rs b/maplibre/src/render/builder.rs
index 001f366b..c4153b7e 100644
--- a/maplibre/src/render/builder.rs
+++ b/maplibre/src/render/builder.rs
@@ -1,8 +1,12 @@
-use crate::environment::Environment;
-use crate::render::settings::{RendererSettings, WgpuSettings};
-use crate::render::Renderer;
-use crate::style::Style;
-use crate::window::{HeadedMapWindow, MapWindow, MapWindowConfig};
+use crate::{
+    environment::Environment,
+    render::{
+        settings::{RendererSettings, WgpuSettings},
+        Renderer,
+    },
+    style::Style,
+    window::{HeadedMapWindow, MapWindow, MapWindowConfig},
+};
 
 pub struct RenderBuilder {
     wgpu_settings: Option<WgpuSettings>,
diff --git a/maplibre/src/render/error.rs b/maplibre/src/render/error.rs
new file mode 100644
index 00000000..548c07f3
--- /dev/null
+++ b/maplibre/src/render/error.rs
@@ -0,0 +1,36 @@
+use std::fmt;
+
+use crate::{error::Error, render::graph::RenderGraphError};
+
+#[derive(Debug)]
+pub enum RenderError {
+    Surface(wgpu::SurfaceError),
+    Graph(RenderGraphError),
+}
+
+impl fmt::Display for RenderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RenderError::Surface(e) => write!(f, "{}", e),
+            RenderError::Graph(e) => write!(f, "{}", e),
+        }
+    }
+}
+
+impl RenderError {
+    pub fn should_exit(&self) -> bool {
+        match self {
+            RenderError::Surface(e) => match e {
+                wgpu::SurfaceError::OutOfMemory => true,
+                _ => false,
+            },
+            _ => true,
+        }
+    }
+}
+
+impl From<wgpu::SurfaceError> for Error {
+    fn from(e: wgpu::SurfaceError) -> Self {
+        Error::Render(RenderError::Surface(e))
+    }
+}
diff --git a/maplibre/src/render/mod.rs b/maplibre/src/render/mod.rs
index b61ab2d0..d7224b6c 100644
--- a/maplibre/src/render/mod.rs
+++ b/maplibre/src/render/mod.rs
@@ -50,17 +50,20 @@ mod tile_view_pattern;
 // Public API
 pub mod builder;
 pub mod camera;
+pub mod error;
 pub mod eventually;
 pub mod settings;
 
 pub use shaders::ShaderVertex;
 pub use stages::register_default_render_stages;
 
-use crate::render::{
-    graph::{EmptyNode, RenderGraph, RenderGraphError},
-    main_pass::{MainPassDriverNode, MainPassNode},
+use crate::{
+    render::{
+        graph::{EmptyNode, RenderGraph, RenderGraphError},
+        main_pass::{MainPassDriverNode, MainPassNode},
+    },
+    window::{HeadedMapWindow, MapWindow},
 };
-use crate::window::{HeadedMapWindow, MapWindow};
 
 const INDEX_FORMAT: wgpu::IndexFormat = wgpu::IndexFormat::Uint32; // Must match IndexDataType
 
@@ -409,10 +412,11 @@ impl Renderer {
 
 #[cfg(test)]
 mod tests {
-    use crate::render::settings::RendererSettings;
-    use crate::render::RenderState;
-    use crate::window::{MapWindow, MapWindowConfig, WindowSize};
-    use crate::{MapWindow, MapWindowConfig, WindowSize};
+    use crate::{
+        render::{settings::RendererSettings, RenderState},
+        window::{MapWindow, MapWindowConfig, WindowSize},
+        MapWindow, MapWindowConfig, WindowSize,
+    };
 
     pub struct HeadlessMapWindowConfig {
         size: WindowSize,
diff --git a/maplibre/src/render/render_commands.rs b/maplibre/src/render/render_commands.rs
index 64254518..f4bf94de 100644
--- a/maplibre/src/render/render_commands.rs
+++ b/maplibre/src/render/render_commands.rs
@@ -1,13 +1,12 @@
 //! Specifies the instructions which are going to be sent to the GPU. Render commands can be concatenated
 //! into a new render command which executes multiple instruction sets.
 
-use crate::render::RenderState;
 use crate::render::{
     eventually::Eventually::Initialized,
     render_phase::{PhaseItem, RenderCommand, RenderCommandResult},
     resource::{Globals, IndexEntry, TrackedRenderPass},
     tile_view_pattern::{TileInView, TileShape},
-    INDEX_FORMAT,
+    RenderState, INDEX_FORMAT,
 };
 
 impl PhaseItem for TileInView {
diff --git a/maplibre/src/render/render_phase/draw.rs b/maplibre/src/render/render_phase/draw.rs
index 7bf2418a..da7a2953 100644
--- a/maplibre/src/render/render_phase/draw.rs
+++ b/maplibre/src/render/render_phase/draw.rs
@@ -1,5 +1,4 @@
-use crate::render::resource::TrackedRenderPass;
-use crate::render::RenderState;
+use crate::render::{resource::TrackedRenderPass, RenderState};
 
 /// A draw function which is used to draw a specific [`PhaseItem`].
 ///
diff --git a/maplibre/src/render/resource/surface.rs b/maplibre/src/render/resource/surface.rs
index 11ab63c3..c28ae3a9 100644
--- a/maplibre/src/render/resource/surface.rs
+++ b/maplibre/src/render/resource/surface.rs
@@ -3,10 +3,9 @@
 
 use std::{mem::size_of, sync::Arc};
 
-use crate::window::{MapWindow, WindowSize};
 use crate::{
     render::{eventually::HasChanged, resource::texture::TextureView, settings::RendererSettings},
-    window::HeadedMapWindow,
+    window::{HeadedMapWindow, MapWindow, WindowSize},
 };
 
 pub struct BufferDimensions {
diff --git a/maplibre/src/render/stages/extract_stage.rs b/maplibre/src/render/stages/extract_stage.rs
index 5eafa9c8..dd4cb06f 100644
--- a/maplibre/src/render/stages/extract_stage.rs
+++ b/maplibre/src/render/stages/extract_stage.rs
@@ -1,9 +1,11 @@
 //! Extracts data from the current state.
 
-use crate::render::{RenderState, Renderer};
 use crate::{
-    context::MapContext, coords::ViewRegion, render::eventually::Eventually::Initialized,
+    context::MapContext,
+    coords::ViewRegion,
+    render::{eventually::Eventually::Initialized, RenderState, Renderer},
     schedule::Stage,
+    world::World,
 };
 
 #[derive(Default)]
@@ -13,7 +15,7 @@ impl Stage for ExtractStage {
     fn run(
         &mut self,
         MapContext {
-            view_state,
+            world: World { view_state, .. },
             renderer:
                 Renderer {
                     state:
diff --git a/maplibre/src/render/stages/graph_runner_stage.rs b/maplibre/src/render/stages/graph_runner_stage.rs
index 27ebf8ea..bebdbae4 100644
--- a/maplibre/src/render/stages/graph_runner_stage.rs
+++ b/maplibre/src/render/stages/graph_runner_stage.rs
@@ -2,11 +2,11 @@
 
 use log::error;
 
-use crate::render::Renderer;
 use crate::{
     context::MapContext,
     render::{
         eventually::Eventually::Initialized, graph::RenderGraph, graph_runner::RenderGraphRunner,
+        Renderer,
     },
     schedule::Stage,
 };
diff --git a/maplibre/src/render/stages/phase_sort_stage.rs b/maplibre/src/render/stages/phase_sort_stage.rs
index 0a5e22e1..d253f9f2 100644
--- a/maplibre/src/render/stages/phase_sort_stage.rs
+++ b/maplibre/src/render/stages/phase_sort_stage.rs
@@ -1,7 +1,10 @@
 //! Sorts items of the [RenderPhases](RenderPhase).
 
-use crate::render::Renderer;
-use crate::{context::MapContext, render::render_phase::RenderPhase, schedule::Stage};
+use crate::{
+    context::MapContext,
+    render::{render_phase::RenderPhase, Renderer},
+    schedule::Stage,
+};
 
 #[derive(Default)]
 pub struct PhaseSortStage;
diff --git a/maplibre/src/render/stages/queue_stage.rs b/maplibre/src/render/stages/queue_stage.rs
index 583f0dc0..d81b3916 100644
--- a/maplibre/src/render/stages/queue_stage.rs
+++ b/maplibre/src/render/stages/queue_stage.rs
@@ -1,10 +1,10 @@
 //! Queues [PhaseItems](crate::render::render_phase::PhaseItem) for rendering.
 
-use crate::render::{RenderState, Renderer};
 use crate::{
     context::MapContext,
     render::{
         eventually::Eventually::Initialized, resource::IndexEntry, tile_view_pattern::TileInView,
+        RenderState, Renderer,
     },
     schedule::Stage,
 };
@@ -17,7 +17,6 @@ impl Stage for QueueStage {
     fn run(
         &mut self,
         MapContext {
-            view_state: _,
             renderer:
                 Renderer {
                     state:
diff --git a/maplibre/src/render/stages/resource_stage.rs b/maplibre/src/render/stages/resource_stage.rs
index aa562ec5..79758515 100644
--- a/maplibre/src/render/stages/resource_stage.rs
+++ b/maplibre/src/render/stages/resource_stage.rs
@@ -2,7 +2,6 @@
 
 use std::mem::size_of;
 
-use crate::render::Renderer;
 use crate::{
     context::MapContext,
     render::{
@@ -11,6 +10,7 @@ use crate::{
         shaders::{Shader, ShaderTileMetadata},
         tile_pipeline::TilePipeline,
         tile_view_pattern::{TileViewPattern, DEFAULT_TILE_VIEW_SIZE},
+        Renderer,
     },
     schedule::Stage,
 };
diff --git a/maplibre/src/render/stages/upload_stage.rs b/maplibre/src/render/stages/upload_stage.rs
index 745a8d09..2684fc87 100644
--- a/maplibre/src/render/stages/upload_stage.rs
+++ b/maplibre/src/render/stages/upload_stage.rs
@@ -2,8 +2,6 @@
 
 use std::iter;
 
-use crate::render::{RenderState, Renderer};
-use crate::style::Style;
 use crate::{
     context::MapContext,
     coords::ViewRegion,
@@ -12,8 +10,11 @@ use crate::{
         camera::ViewProjection,
         eventually::Eventually::Initialized,
         shaders::{ShaderCamera, ShaderFeatureStyle, ShaderGlobals, ShaderLayerMetadata, Vec4f32},
+        RenderState, Renderer,
     },
     schedule::Stage,
+    style::Style,
+    world::World,
 };
 
 #[derive(Default)]
@@ -24,9 +25,12 @@ impl Stage for UploadStage {
     fn run(
         &mut self,
         MapContext {
-            view_state,
+            world:
+                World {
+                    tile_repository,
+                    view_state,
+                },
             style,
-            tile_repository,
             renderer: Renderer { queue, state, .. },
             ..
         }: &mut MapContext,
@@ -41,8 +45,7 @@ impl Stage for UploadStage {
                 bytemuck::cast_slice(&[ShaderGlobals::new(ShaderCamera::new(
                     view_proj.downcast().into(),
                     view_state
-                        .camera
-                        .position
+                        .camera_position()
                         .to_homogeneous()
                         .cast::<f32>()
                         .unwrap() // TODO: Remove unwrap
diff --git a/maplibre/src/stages/mod.rs b/maplibre/src/stages/mod.rs
index c40095ae..2af6c379 100644
--- a/maplibre/src/stages/mod.rs
+++ b/maplibre/src/stages/mod.rs
@@ -10,16 +10,15 @@ use std::{
 use geozero::{mvt::tile, GeozeroDatasource};
 use request_stage::RequestStage;
 
-use crate::environment::Environment;
-use crate::io::source_client::HttpClient;
 use crate::{
     coords::{WorldCoords, WorldTileCoords, Zoom, ZoomLevel},
+    environment::Environment,
     error::Error,
     io::{
         apc::{AsyncProcedureCall, Context, Message},
         geometry_index::{GeometryIndex, IndexedGeometry, TileIndex},
         pipeline::{PipelineContext, PipelineProcessor, Processable},
-        source_client::HttpSourceClient,
+        source_client::{HttpClient, HttpSourceClient},
         tile_pipelines::build_vector_tile_pipeline,
         transferables::{
             DefaultTessellatedLayer, DefaultTileTessellated, DefaultTransferables,
diff --git a/maplibre/src/stages/populate_tile_store_stage.rs b/maplibre/src/stages/populate_tile_store_stage.rs
index 2c492b9c..1c97b8e1 100644
--- a/maplibre/src/stages/populate_tile_store_stage.rs
+++ b/maplibre/src/stages/populate_tile_store_stage.rs
@@ -2,15 +2,16 @@
 
 use std::{borrow::BorrowMut, cell::RefCell, ops::Deref, rc::Rc};
 
-use crate::environment::Environment;
 use crate::{
     context::MapContext,
+    environment::Environment,
     io::{
         apc::{AsyncProcedureCall, Message},
         tile_repository::StoredLayer,
         transferables::{TessellatedLayer, TileTessellated, UnavailableLayer},
     },
     schedule::Stage,
+    world::World,
 };
 
 pub struct PopulateTileStore<E: Environment> {
@@ -27,7 +28,10 @@ impl<E: Environment> Stage for PopulateTileStore<E> {
     fn run(
         &mut self,
         MapContext {
-            tile_repository, ..
+            world: World {
+                tile_repository, ..
+            },
+            ..
         }: &mut MapContext,
     ) {
         if let Ok(mut apc) = self.apc.deref().try_borrow_mut() {
diff --git a/maplibre/src/stages/request_stage.rs b/maplibre/src/stages/request_stage.rs
index 8899ab79..c0393db2 100644
--- a/maplibre/src/stages/request_stage.rs
+++ b/maplibre/src/stages/request_stage.rs
@@ -12,11 +12,10 @@ use std::{
     str::FromStr,
 };
 
-use crate::environment::Environment;
-use crate::style::Style;
 use crate::{
     context::MapContext,
     coords::{ViewRegion, WorldTileCoords, ZoomLevel},
+    environment::Environment,
     error::Error,
     io::{
         apc::{AsyncProcedureCall, AsyncProcedureFuture, Context, Input, Message},
@@ -29,6 +28,8 @@ use crate::{
     },
     schedule::Stage,
     stages::HeadedPipelineProcessor,
+    style::Style,
+    world::World,
 };
 
 pub struct RequestStage<E: Environment> {
@@ -52,23 +53,25 @@ impl<E: Environment> Stage for RequestStage<E> {
     fn run(
         &mut self,
         MapContext {
-            view_state,
+            world:
+                World {
+                    tile_repository,
+                    view_state,
+                },
             style,
-            tile_repository,
             ..
         }: &mut MapContext,
     ) {
         let view_region = view_state.create_view_region();
 
-        if view_state.camera.did_change(0.05) || view_state.zoom.did_change(0.05) {
+        if view_state.did_camera_change() || view_state.did_zoom_change() {
             if let Some(view_region) = &view_region {
                 // FIXME: We also need to request tiles from layers above if we are over the maximum zoom level
                 self.request_tiles_in_view(tile_repository, style, view_region);
             }
         }
 
-        view_state.camera.update_reference();
-        view_state.zoom.update_reference();
+        view_state.update_references();
     }
 }
 
@@ -133,7 +136,7 @@ impl<E: Environment> RequestStage<E> {
         for coords in view_region.iter() {
             if coords.build_quad_key().is_some() {
                 // TODO: Make tesselation depend on style?
-                self.request_tile(tile_repository, &coords, &source_layers)
+                self.request_tile(tile_repository, coords, &source_layers)
                     .unwrap(); // TODO: Remove unwrap
             }
         }
@@ -142,7 +145,7 @@ impl<E: Environment> RequestStage<E> {
     fn request_tile(
         &self,
         tile_repository: &mut TileRepository,
-        coords: &WorldTileCoords,
+        coords: WorldTileCoords,
         layers: &HashSet<String>,
     ) -> Result<(), Error> {
         /*        if !tile_repository.is_layers_missing(coords, layers) {
@@ -155,7 +158,7 @@ impl<E: Environment> RequestStage<E> {
             tracing::info!("new tile request: {}", &coords);
             self.apc.deref().borrow().schedule(
                 Input::TileRequest(TileRequest {
-                    coords: *coords,
+                    coords,
                     layers: layers.clone(),
                 }),
                 schedule::<
diff --git a/maplibre/src/window.rs b/maplibre/src/window.rs
index 4bf68471..91c0d994 100644
--- a/maplibre/src/window.rs
+++ b/maplibre/src/window.rs
@@ -2,10 +2,10 @@
 
 use std::{cell::RefCell, rc::Rc};
 
-use crate::environment::Environment;
-use crate::map_schedule::InteractiveMapSchedule;
 use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
 
+use crate::{environment::Environment, map_schedule::InteractiveMapSchedule};
+
 /// Window of a certain [`WindowSize`]. This can either be a proper window or a headless one.
 pub trait MapWindow {
     fn size(&self) -> WindowSize;
diff --git a/maplibre/src/world.rs b/maplibre/src/world.rs
new file mode 100644
index 00000000..cd87979d
--- /dev/null
+++ b/maplibre/src/world.rs
@@ -0,0 +1,143 @@
+use cgmath::{Angle, Point3};
+
+use crate::{
+    coords::{LatLon, ViewRegion, WorldCoords, Zoom, ZoomLevel, TILE_SIZE},
+    io::tile_repository::TileRepository,
+    render::camera::{Camera, Perspective, ViewProjection},
+    util::ChangeObserver,
+    window::WindowSize,
+};
+
+pub struct World {
+    pub view_state: ViewState,
+    pub tile_repository: TileRepository,
+}
+
+impl World {
+    pub fn new_at<P: Into<cgmath::Deg<f64>>>(
+        window_size: WindowSize,
+        initial_center: LatLon,
+        initial_zoom: Zoom,
+        pitch: P,
+    ) -> Self {
+        Self::new(
+            window_size,
+            WorldCoords::from_lat_lon(initial_center, initial_zoom),
+            initial_zoom,
+            pitch,
+        )
+    }
+
+    pub fn new<P: Into<cgmath::Deg<f64>>>(
+        window_size: WindowSize,
+        initial_center: WorldCoords,
+        initial_zoom: Zoom,
+        pitch: P,
+    ) -> Self {
+        let position = initial_center;
+        let view_state = ViewState::new(
+            window_size,
+            position,
+            initial_zoom,
+            pitch,
+            cgmath::Deg(110.0),
+        );
+
+        let tile_repository = TileRepository::new();
+
+        World {
+            view_state,
+            tile_repository,
+        }
+    }
+}
+
+/// Stores the camera configuration.
+pub struct ViewState {
+    zoom: ChangeObserver<Zoom>,
+    camera: ChangeObserver<Camera>,
+    perspective: Perspective,
+}
+
+impl ViewState {
+    pub fn new<F: Into<cgmath::Rad<f64>>, P: Into<cgmath::Deg<f64>>>(
+        window_size: WindowSize,
+        position: WorldCoords,
+        zoom: Zoom,
+        pitch: P,
+        fovy: F,
+    ) -> Self {
+        let tile_center = TILE_SIZE / 2.0;
+        let fovy = fovy.into();
+        let height = tile_center / (fovy / 2.0).tan();
+
+        let camera = Camera::new(
+            (position.x, position.y, height),
+            cgmath::Deg(-90.0),
+            pitch.into(),
+            window_size.width(),
+            window_size.height(),
+        );
+
+        let perspective = Perspective::new(
+            window_size.width(),
+            window_size.height(),
+            cgmath::Deg(110.0),
+            // in tile.vertex.wgsl we are setting each layer's final `z` in ndc space to `z_index`.
+            // This means that regardless of the `znear` value all layers will be rendered as part
+            // of the near plane.
+            // These values have been selected experimentally:
+            // https://www.sjbaker.org/steve/omniv/love_your_z_buffer.html
+            1024.0,
+            2048.0,
+        );
+
+        Self {
+            zoom: ChangeObserver::new(zoom),
+            camera: ChangeObserver::new(camera),
+            perspective,
+        }
+    }
+
+    pub fn create_view_region(&self) -> Option<ViewRegion> {
+        self.camera
+            .view_region_bounding_box(&self.view_projection().invert())
+            .map(|bounding_box| {
+                ViewRegion::new(bounding_box, 0, 32, *self.zoom, self.visible_level())
+            })
+    }
+
+    pub fn view_projection(&self) -> ViewProjection {
+        self.camera.calc_view_proj(&self.perspective)
+    }
+
+    pub fn visible_level(&self) -> ZoomLevel {
+        self.zoom.level()
+    }
+
+    pub fn zoom(&self) -> Zoom {
+        *self.zoom
+    }
+
+    pub fn camera_position(&self) -> Point3<f64> {
+        self.camera.position
+    }
+
+    pub fn did_zoom_change(&self) -> bool {
+        self.zoom.did_change(0.05)
+    }
+
+    pub fn did_camera_change(&self) -> bool {
+        self.camera.did_change(0.05)
+    }
+
+    pub fn update_references(&mut self) {
+        self.camera.update_reference();
+        self.zoom.update_reference();
+    }
+
+    pub fn update_zoom(&mut self, new_zoom: Zoom) {
+        *self.zoom = new_zoom;
+        log::info!("zoom: {}", new_zoom);
+    }
+}

From c6eadbf2cc6841bccf07321f08920d148d0c90cc Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 25 Sep 2022 16:25:00 +0200
Subject: [PATCH 03/31] Fix compilation issues and cleanup

---
 maplibre/src/context.rs                 |   7 +
 maplibre/src/error.rs                   |   9 +
 maplibre/src/headless/map.rs            |  15 +-
 maplibre/src/headless/mod.rs            |   4 +-
 maplibre/src/headless/window.rs         |   8 +-
 maplibre/src/lib.rs                     |  10 +-
 maplibre/src/map.rs                     |  83 ++++-----
 maplibre/src/map_schedule.rs            | 218 +++---------------------
 maplibre/src/render/builder.rs          |  74 ++++++--
 maplibre/src/render/error.rs            |  16 +-
 maplibre/src/render/resource/surface.rs |   4 +-
 maplibre/src/window.rs                  |  11 +-
 maplibre/src/world.rs                   |   5 +
 13 files changed, 189 insertions(+), 275 deletions(-)

diff --git a/maplibre/src/context.rs b/maplibre/src/context.rs
index cb970f2c..20f06401 100644
--- a/maplibre/src/context.rs
+++ b/maplibre/src/context.rs
@@ -6,3 +6,10 @@ pub struct MapContext {
     pub world: World,
     pub renderer: Renderer,
 }
+
+impl MapContext {
+    pub fn resize(&mut self, width: u32, height: u32) {
+        self.world.view_state.resize(width, height);
+        self.renderer.resize(width, height)
+    }
+}
diff --git a/maplibre/src/error.rs b/maplibre/src/error.rs
index 4d5f7fbe..cd2d1fe3 100644
--- a/maplibre/src/error.rs
+++ b/maplibre/src/error.rs
@@ -15,6 +15,15 @@ pub enum Error {
     Render(RenderError),
 }
 
+impl<E> From<E> for Error
+where
+    E: Into<RenderError>,
+{
+    fn from(e: E) -> Self {
+        Error::Render(e.into())
+    }
+}
+
 impl From<TessellationError> for Error {
     fn from(e: TessellationError) -> Self {
         Error::Tesselation(e)
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index 54deef43..33ec7861 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -1,4 +1,5 @@
 use crate::io::pipeline::Processable;
+use crate::render::builder::UninitializedRenderer;
 use crate::{
     context::MapContext,
     coords::{WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
@@ -28,19 +29,19 @@ use crate::{
 use std::collections::HashSet;
 
 pub struct HeadlessMap {
-    window_size: WindowSize,
     kernel: Kernel<HeadlessEnvironment>,
-    map_context: MapContext,
     schedule: Schedule,
+    map_context: MapContext,
 }
 
 impl HeadlessMap {
     pub fn new(
         style: Style,
-        window_size: WindowSize,
         renderer: Renderer,
         kernel: Kernel<HeadlessEnvironment>,
     ) -> Result<Self, Error> {
+        let window_size = renderer.state().surface().size();
+
         let world = World::new(
             window_size,
             WorldCoords::from((TILE_SIZE / 2., TILE_SIZE / 2.)),
@@ -67,7 +68,6 @@ impl HeadlessMap {
         );
 
         Ok(Self {
-            window_size,
             kernel,
             map_context: MapContext {
                 style,
@@ -94,7 +94,7 @@ impl HeadlessMap {
     pub async fn fetch_tile(
         &self,
         coords: WorldTileCoords,
-        source_layers: HashSet<String>,
+        source_layers: &[&str],
     ) -> Result<StoredTile, Error> {
         let source_client = &self.kernel.source_client;
 
@@ -107,7 +107,10 @@ impl HeadlessMap {
             (
                 TileRequest {
                     coords: WorldTileCoords::default(),
-                    layers: source_layers,
+                    layers: source_layers
+                        .iter()
+                        .map(|layer| layer.to_string())
+                        .collect::<HashSet<String>>(),
                 },
                 data,
             ),
diff --git a/maplibre/src/headless/mod.rs b/maplibre/src/headless/mod.rs
index 24362188..3b7eefbc 100644
--- a/maplibre/src/headless/mod.rs
+++ b/maplibre/src/headless/mod.rs
@@ -1,6 +1,6 @@
-mod environment;
 mod graph_node;
 mod stage;
-mod window;
 
+pub mod environment;
 pub mod map;
+pub mod window;
diff --git a/maplibre/src/headless/window.rs b/maplibre/src/headless/window.rs
index 7faf5991..16454962 100644
--- a/maplibre/src/headless/window.rs
+++ b/maplibre/src/headless/window.rs
@@ -1,7 +1,13 @@
 use crate::window::{MapWindow, MapWindowConfig, WindowSize};
 
 pub struct HeadlessMapWindowConfig {
-    pub size: WindowSize,
+    size: WindowSize,
+}
+
+impl HeadlessMapWindowConfig {
+    pub fn new(size: WindowSize) -> Self {
+        Self { size }
+    }
 }
 
 impl MapWindowConfig for HeadlessMapWindowConfig {
diff --git a/maplibre/src/lib.rs b/maplibre/src/lib.rs
index 50774a5d..2f702f18 100644
--- a/maplibre/src/lib.rs
+++ b/maplibre/src/lib.rs
@@ -16,14 +16,15 @@
 //! maplibre = "0.0.2"
 //! ```
 
+// Internal modules
+pub(crate) mod tessellation;
+
 pub mod context;
 pub mod coords;
 pub mod error;
 #[cfg(feature = "headless")]
 pub mod headless;
 pub mod io;
-// Exposed because of input handlers in maplibre-winit
-pub mod map_schedule;
 pub mod platform;
 // TODO: Exposed because of camera
 pub mod render;
@@ -41,9 +42,8 @@ pub mod environment;
 // Used for benchmarking
 pub mod benchmarking;
 
-// Internal modules
-pub(crate) mod tessellation;
-mod world;
+pub mod map;
+pub mod world;
 
 // Export tile format
 pub use geozero::mvt::tile;
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index 3f7952fc..4a71ff99 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -1,47 +1,50 @@
-/// The [`Map`] defines the public interface of the map renderer.
-// DO NOT IMPLEMENT INTERNALS ON THIS STRUCT.
+use crate::context::MapContext;
+use crate::coords::{LatLon, WorldCoords, Zoom, TILE_SIZE};
+use crate::environment::{Environment, Kernel};
+use crate::error::Error;
+use crate::headless::environment::HeadlessEnvironment;
+use crate::render::{create_default_render_graph, register_default_render_stages, Renderer};
+use crate::schedule::{Schedule, Stage};
+use crate::style::Style;
+use crate::world::World;
+
 pub struct Map<E: Environment> {
-    // FIXME (wasm-executor): Avoid RefCell, change ownership model!
-    map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>,
-    window: RefCell<Option<<E::MapWindowConfig as MapWindowConfig>::MapWindow>>,
+    kernel: Kernel<E>,
+    schedule: Schedule,
+    map_context: MapContext,
 }
 
-impl<E: Environment> Map<E>
-where
-    <E::MapWindowConfig as MapWindowConfig>::MapWindow: EventLoop<E>,
-{
-    /// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
-    pub fn run(&self) {
-        self.run_with_optionally_max_frames(None);
+impl<E: Environment> Map<E> {
+    pub fn new(style: Style, kernel: Kernel<E>, renderer: Renderer) -> Result<Self, Error> {
+        let window_size = renderer.state().surface().size();
+
+        let center = style.center.unwrap_or_default();
+        let world = World::new_at(
+            window_size,
+            LatLon::new(center[0], center[1]),
+            style.zoom.map(|zoom| Zoom::new(zoom)).unwrap_or_default(),
+            cgmath::Deg::<f64>(style.pitch.unwrap_or_default()),
+        );
+
+        let mut schedule = Schedule::default();
+
+        let graph = create_default_render_graph().unwrap(); // TODO: Remove unwrap
+        register_default_render_stages(graph, &mut schedule);
+
+        Ok(Self {
+            kernel,
+            map_context: MapContext {
+                style,
+                world,
+                renderer,
+            },
+            schedule,
+        })
     }
 
-    /// Starts the [`crate::map_schedule::MapState`] Runnable with the configured event loop.
-    ///
-    /// # Arguments
-    ///
-    /// * `max_frames` - Maximum number of frames per second.
-    pub fn run_with_max_frames(&self, max_frames: u64) {
-        self.run_with_optionally_max_frames(Some(max_frames));
+    #[tracing::instrument(name = "update_and_redraw", skip_all)]
+    pub fn run_schedule(&mut self) -> Result<(), Error> {
+        self.schedule.run(&mut self.map_context);
+        Ok(())
     }
-
-    /// Starts the MapState Runnable with the configured event loop.
-    ///
-    /// # Arguments
-    ///
-    /// * `max_frames` - Optional maximum number of frames per second.
-    pub fn run_with_optionally_max_frames(&self, max_frames: Option<u64>) {
-        self.window
-            .borrow_mut()
-            .take()
-            .unwrap() // FIXME (wasm-executor): Remove unwrap
-            .run(self.map_schedule.clone(), max_frames);
-    }
-
-    pub fn map_schedule(&self) -> Rc<RefCell<InteractiveMapSchedule<E>>> {
-        self.map_schedule.clone()
-    }
-
-    /*    pub fn map_schedule_mut(&mut self) -> &mut InteractiveMapSchedule<E> {
-        &mut self.map_schedule
-    }*/
 }
diff --git a/maplibre/src/map_schedule.rs b/maplibre/src/map_schedule.rs
index c191cd35..afea13f9 100644
--- a/maplibre/src/map_schedule.rs
+++ b/maplibre/src/map_schedule.rs
@@ -1,198 +1,26 @@
-use std::{cell::RefCell, marker::PhantomData, mem, rc::Rc};
+/*    pub fn resume(&mut self, window: &<E::MapWindowConfig as MapWindowConfig>::MapWindow) {
+    if let EventuallyMapContext::Full(map_context) = &mut self.map_context {
+        let renderer = &mut map_context.renderer;
+        renderer.state.recreate_surface(window, &renderer.instance);
+    }
+}*/
 
-use crate::{
-    context::MapContext,
-    coords::{LatLon, WorldCoords, Zoom, TILE_SIZE},
-    environment::Environment,
-    error::Error,
-    io::{
-        scheduler::Scheduler,
-        source_client::{HttpClient, HttpSourceClient},
-        tile_repository::TileRepository,
-    },
-    render::{
-        create_default_render_graph, register_default_render_stages,
-        settings::{RendererSettings, WgpuSettings},
-        Renderer,
-    },
-    schedule::{Schedule, Stage},
-    stages::register_stages,
-    style::Style,
-    window::{HeadedMapWindow, MapWindowConfig, WindowSize},
-    world::{ViewState, World},
-};
-
-/// Stores the state of the map, dispatches tile fetching and caching, tessellation and drawing.
-pub struct InteractiveMapSchedule<E: Environment> {
-    map_window_config: E::MapWindowConfig,
-
-    // FIXME (wasm-executor): avoid RefCell, change ownership model
-    pub apc: Rc<RefCell<E::AsyncProcedureCall>>,
-
-    map_context: EventuallyMapContext,
-
-    schedule: Schedule,
-
-    suspended: bool,
-}
-
-impl<E: Environment> InteractiveMapSchedule<E> {
-    pub fn new(window_size: WindowSize, renderer: Option<Renderer>, style: Style) -> Self {
-        let center = style.center.unwrap_or_default();
-        let world = World::new_at(
-            window_size,
-            LatLon::new(center[0], center[1]),
-            style.zoom.map(|zoom| Zoom::new(zoom)).unwrap_or_default(),
-            cgmath::Deg::<f64>(style.pitch.unwrap_or_default()),
-        );
-
-        let mut schedule = Schedule::default();
-
-        let apc = Rc::new(RefCell::new(apc));
-
-        let http_source_client: HttpSourceClient<E::HttpClient> =
-            HttpSourceClient::new(http_client);
-        register_stages::<E>(&mut schedule, http_source_client, apc.clone());
-
-        let graph = create_default_render_graph().unwrap(); // TODO: Remove unwrap
-        register_default_render_stages(graph, &mut schedule);
-
-        Self {
-            apc,
-            map_window_config,
-            map_context: match renderer {
-                None => EventuallyMapContext::Premature(PrematureMapContext {
-                    world,
-                    style,
-                    wgpu_settings,
-                    renderer_settings,
-                }),
-                Some(renderer) => EventuallyMapContext::Full(MapContext {
-                    world,
-                    style,
-                    renderer,
-                }),
-            },
-            schedule,
-            suspended: false,
+/*    pub async fn late_init(&mut self) -> bool {
+    match &self.map_context {
+        EventuallyMapContext::Full(_) => false,
+        EventuallyMapContext::Uninizalized(PrematureMapContext {
+            wgpu_settings,
+            renderer_settings,
+            ..
+        }) => {
+            let window = self.map_window_config.create();
+            let renderer =
+                Renderer::initialize(&window, wgpu_settings.clone(), renderer_settings.clone())
+                    .await
+                    .unwrap(); // TODO: Remove unwrap
+            self.map_context.make_full(renderer);
+            true
         }
+        EventuallyMapContext::_Uninitialized => false,
     }
-
-    #[tracing::instrument(name = "update_and_redraw", skip_all)]
-    pub fn update_and_redraw(&mut self) -> Result<(), Error> {
-        if self.suspended {
-            return Ok(());
-        }
-
-        if let EventuallyMapContext::Full(map_context) = &mut self.map_context {
-            self.schedule.run(map_context)
-        }
-
-        Ok(())
-    }
-
-    pub fn resize(&mut self, width: u32, height: u32) {
-        if let EventuallyMapContext::Full(map_context) = &mut self.map_context {
-            let view_state = &mut map_context.view_state;
-            view_state.perspective.resize(width, height);
-            view_state.camera.resize(width, height);
-
-            map_context.renderer.resize(width, height)
-        }
-    }
-
-    pub fn is_initialized(&self) -> bool {
-        match &self.map_context {
-            EventuallyMapContext::Full(_) => true,
-            _ => false,
-        }
-    }
-
-    pub fn view_state_mut(&mut self) -> &mut ViewState {
-        match &mut self.map_context {
-            EventuallyMapContext::Full(MapContext { view_state, .. }) => view_state,
-            EventuallyMapContext::Premature(PrematureMapContext { view_state, .. }) => view_state,
-            _ => panic!("should not happen"),
-        }
-    }
-
-    pub fn apc(&self) -> &Rc<RefCell<E::AsyncProcedureCall>> {
-        &self.apc
-    }
-}
-
-impl<E: Environment> InteractiveMapSchedule<E>
-where
-    <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
-{
-    pub fn suspend(&mut self) {
-        self.suspended = true;
-    }
-
-    pub fn resume(&mut self, window: &<E::MapWindowConfig as MapWindowConfig>::MapWindow) {
-        if let EventuallyMapContext::Full(map_context) = &mut self.map_context {
-            let renderer = &mut map_context.renderer;
-            renderer.state.recreate_surface(window, &renderer.instance);
-            self.suspended = false;
-        }
-    }
-
-    pub async fn late_init(&mut self) -> bool {
-        match &self.map_context {
-            EventuallyMapContext::Full(_) => false,
-            EventuallyMapContext::Premature(PrematureMapContext {
-                wgpu_settings,
-                renderer_settings,
-                ..
-            }) => {
-                let window = self.map_window_config.create();
-                let renderer =
-                    Renderer::initialize(&window, wgpu_settings.clone(), renderer_settings.clone())
-                        .await
-                        .unwrap(); // TODO: Remove unwrap
-                self.map_context.make_full(renderer);
-                true
-            }
-            EventuallyMapContext::_Uninitialized => false,
-        }
-    }
-}
-
-pub struct PrematureMapContext {
-    world: World,
-
-    style: Style,
-
-    wgpu_settings: WgpuSettings,
-    renderer_settings: RendererSettings,
-}
-
-pub enum EventuallyMapContext {
-    Full(MapContext),
-    Premature(PrematureMapContext),
-    _Uninitialized,
-}
-
-impl EventuallyMapContext {
-    pub fn make_full(&mut self, renderer: Renderer) {
-        let context = mem::replace(self, EventuallyMapContext::_Uninitialized);
-
-        match context {
-            EventuallyMapContext::Full(_) => {}
-            EventuallyMapContext::Premature(PrematureMapContext {
-                view_state,
-                style,
-                tile_repository,
-                ..
-            }) => {
-                *self = EventuallyMapContext::Full(MapContext {
-                    view_state,
-                    style,
-                    tile_repository,
-                    renderer,
-                });
-            }
-            EventuallyMapContext::_Uninitialized => {}
-        }
-    }
-}
+}*/
diff --git a/maplibre/src/render/builder.rs b/maplibre/src/render/builder.rs
index c4153b7e..355d9c99 100644
--- a/maplibre/src/render/builder.rs
+++ b/maplibre/src/render/builder.rs
@@ -1,3 +1,5 @@
+use crate::environment::Kernel;
+use crate::error::Error;
 use crate::{
     environment::Environment,
     render::{
@@ -14,6 +16,13 @@ pub struct RenderBuilder {
 }
 
 impl RenderBuilder {
+    pub fn new() -> Self {
+        Self {
+            wgpu_settings: None,
+            renderer_settings: None,
+        }
+    }
+
     pub fn with_renderer_settings(mut self, renderer_settings: RendererSettings) -> Self {
         self.renderer_settings = Some(renderer_settings);
         self
@@ -32,6 +41,20 @@ impl RenderBuilder {
     }
 }
 
+pub enum InitializationResult {
+    Initialized(Renderer),
+    Uninizalized(UninitializedRenderer),
+}
+
+impl InitializationResult {
+    pub fn unwarp(self) -> Renderer {
+        match self {
+            InitializationResult::Initialized(renderer) => renderer,
+            InitializationResult::Uninizalized(_) => panic!("Renderer is not initialized"),
+        }
+    }
+}
+
 pub struct UninitializedRenderer {
     wgpu_settings: WgpuSettings,
     renderer_settings: RendererSettings,
@@ -40,41 +63,64 @@ pub struct UninitializedRenderer {
 impl UninitializedRenderer {
     /// Initializes the whole rendering pipeline for the given configuration.
     /// Returns the initialized map, ready to be run.
-    pub async fn initialize<MWC: MapWindowConfig>(self, map_window_config: MWC) -> Option<Renderer>
+    async fn initialize<MWC: MapWindowConfig>(
+        self,
+        map_window_config: &MWC,
+    ) -> Result<InitializationResult, Error>
     where
         MWC::MapWindow: MapWindow + HeadedMapWindow,
     {
         let window = map_window_config.create();
 
         #[cfg(target_os = "android")]
-        let renderer = None;
+        let renderer = Ok(InitializationResult::Uninizalized(self));
         #[cfg(not(target_os = "android"))]
-        let renderer = Renderer::initialize(
-            &window,
-            self.wgpu_settings.clone(),
-            self.renderer_settings.clone(),
-        )
-        .await
-        .ok();
+        let renderer = Ok(InitializationResult::Initialized(
+            Renderer::initialize(
+                &window,
+                self.wgpu_settings.clone(),
+                self.renderer_settings.clone(),
+            )
+            .await?,
+        ));
 
         renderer
     }
+
+    pub async fn initialize_with<E: Environment>(
+        self,
+        kernel: &Kernel<E>,
+    ) -> Result<InitializationResult, Error>
+    where
+        <E::MapWindowConfig as MapWindowConfig>::MapWindow: MapWindow + HeadedMapWindow,
+    {
+        self.initialize(&kernel.map_window_config).await
+    }
 }
 
 #[cfg(feature = "headless")]
 impl UninitializedRenderer {
-    pub async fn initialize_headless<MWC: MapWindowConfig>(
+    async fn initialize_headless<MWC: MapWindowConfig>(
         self,
         map_window_config: MWC,
-    ) -> Option<Renderer> {
+    ) -> Result<Renderer, Error> {
         let window = map_window_config.create();
 
-        Renderer::initialize_headless(
+        Ok(Renderer::initialize_headless(
             &window,
             self.wgpu_settings.clone(),
             self.renderer_settings.clone(),
         )
-        .await
-        .ok()
+        .await?)
+    }
+
+    pub async fn initialize_headless_with<E: Environment>(
+        self,
+        kernel: &Kernel<E>,
+    ) -> Result<InitializationResult, Error>
+    where
+        <E::MapWindowConfig as MapWindowConfig>::MapWindow: MapWindow + HeadedMapWindow,
+    {
+        self.initialize(&kernel.map_window_config).await
     }
 }
diff --git a/maplibre/src/render/error.rs b/maplibre/src/render/error.rs
index 548c07f3..3bd2c81c 100644
--- a/maplibre/src/render/error.rs
+++ b/maplibre/src/render/error.rs
@@ -6,13 +6,15 @@ use crate::{error::Error, render::graph::RenderGraphError};
 pub enum RenderError {
     Surface(wgpu::SurfaceError),
     Graph(RenderGraphError),
+    Device(wgpu::RequestDeviceError),
 }
 
 impl fmt::Display for RenderError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             RenderError::Surface(e) => write!(f, "{}", e),
-            RenderError::Graph(e) => write!(f, "{}", e),
+            RenderError::Graph(e) => write!(f, "{:?}", e),
+            RenderError::Device(e) => write!(f, "{}", e),
         }
     }
 }
@@ -29,8 +31,20 @@ impl RenderError {
     }
 }
 
+impl From<RenderGraphError> for RenderError {
+    fn from(e: RenderGraphError) -> Self {
+        RenderError::Graph(e)
+    }
+}
+
 impl From<wgpu::SurfaceError> for Error {
     fn from(e: wgpu::SurfaceError) -> Self {
         Error::Render(RenderError::Surface(e))
     }
 }
+
+impl From<wgpu::RequestDeviceError> for Error {
+    fn from(e: wgpu::RequestDeviceError) -> Self {
+        Error::Render(RenderError::Device(e))
+    }
+}
diff --git a/maplibre/src/render/resource/surface.rs b/maplibre/src/render/resource/surface.rs
index c28ae3a9..4a5ad66d 100644
--- a/maplibre/src/render/resource/surface.rs
+++ b/maplibre/src/render/resource/surface.rs
@@ -50,7 +50,7 @@ impl WindowHead {
     where
         MW: MapWindow + HeadedMapWindow,
     {
-        self.surface = unsafe { instance.create_surface(window.inner()) };
+        self.surface = unsafe { instance.create_surface(window.raw()) };
     }
     pub fn surface(&self) -> &wgpu::Surface {
         &self.surface
@@ -140,7 +140,7 @@ impl Surface {
             present_mode: wgpu::PresentMode::Fifo, // VSync
         };
 
-        let surface = unsafe { instance.create_surface(window.inner()) };
+        let surface = unsafe { instance.create_surface(window.raw()) };
 
         Self {
             size,
diff --git a/maplibre/src/window.rs b/maplibre/src/window.rs
index 91c0d994..79eb5bf9 100644
--- a/maplibre/src/window.rs
+++ b/maplibre/src/window.rs
@@ -4,7 +4,7 @@ use std::{cell::RefCell, rc::Rc};
 
 use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
 
-use crate::{environment::Environment, map_schedule::InteractiveMapSchedule};
+use crate::environment::Environment;
 
 /// Window of a certain [`WindowSize`]. This can either be a proper window or a headless one.
 pub trait MapWindow {
@@ -16,7 +16,7 @@ pub trait MapWindow {
 pub trait HeadedMapWindow: MapWindow {
     type RawWindow: HasRawWindowHandle + HasRawDisplayHandle;
 
-    fn inner(&self) -> &Self::RawWindow;
+    fn raw(&self) -> &Self::RawWindow;
 }
 
 /// A configuration for a window which determines the corresponding implementation of a
@@ -27,13 +27,6 @@ pub trait MapWindowConfig: 'static {
     fn create(&self) -> Self::MapWindow;
 }
 
-/// The event loop is responsible for processing events and propagating them to the map renderer.
-/// Only non-headless windows use an [`EventLoop`].
-pub trait EventLoop<E: Environment> {
-    // FIXME (wasm-executor): Avoid Rc, change ownership model
-    fn run(self, map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>, max_frames: Option<u64>);
-}
-
 /// Window size with a width and an height in pixels.
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub struct WindowSize {
diff --git a/maplibre/src/world.rs b/maplibre/src/world.rs
index cd87979d..8f056de6 100644
--- a/maplibre/src/world.rs
+++ b/maplibre/src/world.rs
@@ -99,6 +99,11 @@ impl ViewState {
         }
     }
 
+    pub fn resize(&mut self, width: u32, height: u32) {
+        self.perspective.resize(width, height);
+        self.camera.resize(width, height);
+    }
+
     pub fn create_view_region(&self) -> Option<ViewRegion> {
         self.camera
             .view_region_bounding_box(&self.view_projection().invert())

From c663416d05ca839f7cbb1d543fbae374e3b81e52 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 25 Sep 2022 17:41:59 +0200
Subject: [PATCH 04/31] Fix compilation in winit and demo module

---
 maplibre-demo/src/headless.rs                 |  57 ++---
 maplibre-winit/src/input/mod.rs               |   2 +-
 maplibre-winit/src/input/pan_handler.rs       |  10 +-
 maplibre-winit/src/input/pinch_handler.rs     |   2 +-
 maplibre-winit/src/input/query_handler.rs     |   4 +-
 maplibre-winit/src/input/shift_handler.rs     |   4 +-
 maplibre-winit/src/input/tilt_handler.rs      |   4 +-
 maplibre-winit/src/input/zoom_handler.rs      |   6 +-
 maplibre-winit/src/winit/mod.rs               | 240 +++++++++---------
 maplibre-winit/src/winit/noweb.rs             |  57 +++--
 maplibre-winit/src/winit/web.rs               |   8 +-
 maplibre/src/environment.rs                   |  60 +----
 maplibre/src/event_loop.rs                    |  29 +++
 maplibre/src/headless/environment.rs          |   2 -
 maplibre/src/headless/map.rs                  |   2 +-
 maplibre/src/io/apc.rs                        |  16 +-
 maplibre/src/kernel.rs                        |  56 ++++
 maplibre/src/lib.rs                           |   2 +
 maplibre/src/map.rs                           |  11 +-
 maplibre/src/render/builder.rs                |  84 +++---
 maplibre/src/render/camera.rs                 |  40 ++-
 maplibre/src/render/stages/upload_stage.rs    |   3 +-
 maplibre/src/stages/mod.rs                    |  14 +-
 .../src/stages/populate_tile_store_stage.rs   |  71 +++---
 maplibre/src/stages/request_stage.rs          |  35 +--
 maplibre/src/window.rs                        |   5 +
 maplibre/src/world.rs                         |  23 +-
 27 files changed, 481 insertions(+), 366 deletions(-)
 create mode 100644 maplibre/src/event_loop.rs
 create mode 100644 maplibre/src/kernel.rs

diff --git a/maplibre-demo/src/headless.rs b/maplibre-demo/src/headless.rs
index 36aefc40..b7faa1cb 100644
--- a/maplibre-demo/src/headless.rs
+++ b/maplibre-demo/src/headless.rs
@@ -1,37 +1,41 @@
+use maplibre::headless::map::HeadlessMap;
+use maplibre::headless::window::HeadlessMapWindowConfig;
+use maplibre::kernel::KernelBuilder;
+use maplibre::render::builder::RenderBuilder;
+use maplibre::style::Style;
 use maplibre::{
     coords::{LatLon, WorldTileCoords},
     error::Error,
-    headless::{HeadlessEnvironment, HeadlessMapWindowConfig},
     io::apc::SchedulerAsyncProcedureCall,
     platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
     render::settings::{RendererSettings, TextureFormat},
     util::grid::google_mercator,
     window::WindowSize,
-    MapBuilder,
 };
 use maplibre_winit::winit::WinitEnvironment;
 use tile_grid::{extent_wgs84_to_merc, Extent, GridIterator};
 
 pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
     let client = ReqwestHttpClient::new(None);
-    let mut map =
-        MapBuilder::<HeadlessEnvironment<_, _, _, SchedulerAsyncProcedureCall<_, _>>>::new()
-            .with_map_window_config(HeadlessMapWindowConfig {
-                size: WindowSize::new(tile_size, tile_size).unwrap(),
-            })
-            .with_http_client(client.clone())
-            .with_apc(SchedulerAsyncProcedureCall::new(
-                client,
-                TokioScheduler::new(),
-            )) // FIXME (wasm-executor): avoid passing client and scheduler here
-            .with_scheduler(TokioScheduler::new())
-            .with_renderer_settings(RendererSettings {
-                texture_format: TextureFormat::Rgba8UnormSrgb,
-                ..RendererSettings::default()
-            })
-            .build()
-            .initialize_headless()
-            .await;
+    let kernel = KernelBuilder::new()
+        .with_map_window_config(HeadlessMapWindowConfig::new(
+            WindowSize::new(tile_size, tile_size).unwrap(),
+        ))
+        .with_http_client(client.clone())
+        .with_apc(SchedulerAsyncProcedureCall::new(
+            client,
+            TokioScheduler::new(),
+        ))
+        .with_scheduler(TokioScheduler::new())
+        .build();
+
+    let renderer = RenderBuilder::new()
+        .build()
+        .initialize_headless_with(&kernel)
+        .await
+        .expect("Failed to initialize renderer");
+
+    let mut map = HeadlessMap::new(Style::default(), renderer, kernel).unwrap();
 
     let tile_limits = google_mercator().tile_limits(
         extent_wgs84_to_merc(&Extent {
@@ -46,18 +50,11 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
     for (z, x, y) in GridIterator::new(10, 10, tile_limits) {
         let coords = WorldTileCoords::from((x as i32, y as i32, z.into()));
         println!("Rendering {}", &coords);
-        map.map_schedule
-            .fetch_process(&coords)
+        let tile = map
+            .fetch_tile(coords, &["water"])
             .await
             .expect("Failed to fetch and process!");
 
-        match map.map_schedule_mut().update_and_redraw() {
-            Ok(_) => {}
-            Err(Error::Render(e)) => {
-                eprintln!("{}", e);
-                if e.should_exit() {}
-            }
-            e => eprintln!("{:?}", e),
-        };
+        map.render_tile(tile);
     }
 }
diff --git a/maplibre-winit/src/input/mod.rs b/maplibre-winit/src/input/mod.rs
index 4f698763..ddcd6bdf 100644
--- a/maplibre-winit/src/input/mod.rs
+++ b/maplibre-winit/src/input/mod.rs
@@ -3,7 +3,7 @@
 use std::time::Duration;
 
 use cgmath::Vector2;
-use maplibre::context::ViewState;
+use maplibre::world::ViewState;
 use winit::event::{DeviceEvent, KeyboardInput, TouchPhase, WindowEvent};
 
 use crate::input::{
diff --git a/maplibre-winit/src/input/pan_handler.rs b/maplibre-winit/src/input/pan_handler.rs
index 0c39815a..323716fe 100644
--- a/maplibre-winit/src/input/pan_handler.rs
+++ b/maplibre-winit/src/input/pan_handler.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use cgmath::{EuclideanSpace, Point3, Vector2, Vector3, Zero};
-use maplibre::{context::ViewState, render::camera::Camera};
+use maplibre::{render::camera::Camera, world::ViewState};
 use winit::event::{ElementState, MouseButton};
 
 use super::UpdateState;
@@ -45,17 +45,17 @@ impl UpdateState for PanHandler {
                 };
 
                 if self.start_camera_position.is_none() {
-                    self.start_camera_position = Some(state.camera.position.to_vec());
+                    self.start_camera_position = Some(state.camera().position().to_vec());
                 }
 
                 if let Some(start_camera_position) = self.start_camera_position {
-                    state.camera.position = Point3::from_vec(
+                    state.camera_mut().move_to(Point3::from_vec(
                         start_camera_position + Vector3::new(delta.x, delta.y, 0.0),
-                    );
+                    ));
                 }
             }
         } else {
-            self.reference_camera = Some(state.camera.clone());
+            self.reference_camera = Some(state.camera().clone());
         }
     }
 }
diff --git a/maplibre-winit/src/input/pinch_handler.rs b/maplibre-winit/src/input/pinch_handler.rs
index a81d7a7c..f345cdbf 100644
--- a/maplibre-winit/src/input/pinch_handler.rs
+++ b/maplibre-winit/src/input/pinch_handler.rs
@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use maplibre::context::ViewState;
+use maplibre::world::ViewState;
 
 use super::UpdateState;
 
diff --git a/maplibre-winit/src/input/query_handler.rs b/maplibre-winit/src/input/query_handler.rs
index 2ed8d60c..98ecc2fd 100644
--- a/maplibre-winit/src/input/query_handler.rs
+++ b/maplibre-winit/src/input/query_handler.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use cgmath::Vector2;
-use maplibre::context::ViewState;
+use maplibre::world::ViewState;
 use winit::event::{ElementState, MouseButton};
 
 use crate::input::UpdateState;
@@ -66,7 +66,7 @@ impl UpdateState for QueryHandler {
                 let _z = state.visible_level(); // FIXME: can be wrong, if tiles of different z are visible
                 let _zoom = state.zoom();
 
-                if let Some(_coordinates) = state.camera.window_to_world_at_ground(
+                if let Some(_coordinates) = state.camera().window_to_world_at_ground(
                     &window_position,
                     &inverted_view_proj,
                     false,
diff --git a/maplibre-winit/src/input/shift_handler.rs b/maplibre-winit/src/input/shift_handler.rs
index 0fa4d24e..9ed5156f 100644
--- a/maplibre-winit/src/input/shift_handler.rs
+++ b/maplibre-winit/src/input/shift_handler.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use cgmath::{Vector3, Zero};
-use maplibre::context::ViewState;
+use maplibre::world::ViewState;
 
 use super::UpdateState;
 
@@ -17,7 +17,7 @@ impl UpdateState for ShiftHandler {
         let dt = dt.as_secs_f64() * (1.0 / self.speed);
 
         let delta = self.camera_translate * dt;
-        state.camera.position += delta;
+        state.camera_mut().move_relative(delta);
         self.camera_translate -= delta;
     }
 }
diff --git a/maplibre-winit/src/input/tilt_handler.rs b/maplibre-winit/src/input/tilt_handler.rs
index 8c48b2f8..115e68fe 100644
--- a/maplibre-winit/src/input/tilt_handler.rs
+++ b/maplibre-winit/src/input/tilt_handler.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use cgmath::{Deg, Rad, Zero};
-use maplibre::context::ViewState;
+use maplibre::world::ViewState;
 
 use super::UpdateState;
 
@@ -17,7 +17,7 @@ impl UpdateState for TiltHandler {
         let dt = dt.as_secs_f64() * (1.0 / self.speed);
 
         let delta = self.delta_pitch * dt;
-        state.camera.pitch += Rad::from(delta);
+        state.camera_mut().pitch_self(delta);
         self.delta_pitch -= delta;
     }
 }
diff --git a/maplibre-winit/src/input/zoom_handler.rs b/maplibre-winit/src/input/zoom_handler.rs
index 9f9dfda2..07481878 100644
--- a/maplibre-winit/src/input/zoom_handler.rs
+++ b/maplibre-winit/src/input/zoom_handler.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use cgmath::{Vector2, Vector3};
-use maplibre::{context::ViewState, coords::Zoom};
+use maplibre::{coords::Zoom, world::ViewState};
 
 use super::UpdateState;
 
@@ -24,7 +24,7 @@ impl UpdateState for ZoomHandler {
                 let view_proj = state.view_projection();
                 let inverted_view_proj = view_proj.invert();
 
-                if let Some(cursor_position) = state.camera.window_to_world_at_ground(
+                if let Some(cursor_position) = state.camera().window_to_world_at_ground(
                     &window_position,
                     &inverted_view_proj,
                     false,
@@ -37,7 +37,7 @@ impl UpdateState for ZoomHandler {
                         cursor_position.z,
                     ) - cursor_position;
 
-                    state.camera.position += delta;
+                    state.camera_mut().move_relative(delta);
                 }
             }
         }
diff --git a/maplibre-winit/src/winit/mod.rs b/maplibre-winit/src/winit/mod.rs
index 7407bf61..97d83847 100644
--- a/maplibre-winit/src/winit/mod.rs
+++ b/maplibre-winit/src/winit/mod.rs
@@ -1,6 +1,7 @@
-use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
-
+use crate::input::{InputController, UpdateState};
 use instant::Instant;
+use maplibre::event_loop::{EventLoop, EventLoopProxy};
+use maplibre::map::Map;
 use maplibre::{
     environment::Environment,
     error::Error,
@@ -10,15 +11,17 @@ use maplibre::{
         source_client::HttpClient,
         transferables::{DefaultTransferables, Transferables},
     },
-    map_schedule::InteractiveMapSchedule,
-    window::{EventLoop, HeadedMapWindow, MapWindowConfig},
+    window::{HeadedMapWindow, MapWindowConfig},
 };
+use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
 use winit::{
     event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
     event_loop::ControlFlow,
 };
 
-use crate::input::{InputController, UpdateState};
+pub type RawWinitWindow = winit::window::Window;
+pub type RawWinitEventLoop<ET> = winit::event_loop::EventLoop<ET>;
+pub type RawEventLoopProxy<ET> = winit::event_loop::EventLoopProxy<ET>;
 
 #[cfg(target_arch = "wasm32")]
 mod web;
@@ -32,14 +35,19 @@ pub use noweb::*;
 pub use web::*;
 
 #[cfg(not(target_arch = "wasm32"))]
-pub struct WinitMapWindowConfig {
+pub struct WinitMapWindowConfig<ET> {
     title: String,
+
+    phantom_et: PhantomData<ET>,
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-impl WinitMapWindowConfig {
+impl<ET> WinitMapWindowConfig<ET> {
     pub fn new(title: String) -> Self {
-        Self { title }
+        Self {
+            title,
+            phantom_et: Default::default(),
+        }
     }
 }
 
@@ -55,151 +63,157 @@ impl WinitMapWindowConfig {
     }
 }
 
-pub struct WinitMapWindow {
-    window: WinitWindow,
-    event_loop: Option<WinitEventLoop>,
+pub struct WinitMapWindow<ET: 'static> {
+    window: RawWinitWindow,
+    event_loop: Option<WinitEventLoop<ET>>,
 }
 
-impl WinitMapWindow {
-    pub fn take_event_loop(&mut self) -> Option<WinitEventLoop> {
+impl<ET> WinitMapWindow<ET> {
+    pub fn take_event_loop(&mut self) -> Option<WinitEventLoop<ET>> {
         self.event_loop.take()
     }
 }
 
-pub type WinitWindow = winit::window::Window;
-pub type WinitEventLoop = winit::event_loop::EventLoop<()>;
-
-pub struct WinitEnvironment<
-    S: Scheduler,
-    HC: HttpClient,
-    T: Transferables,
-    APC: AsyncProcedureCall<T, HC>,
-> {
-    phantom_s: PhantomData<S>,
-    phantom_hc: PhantomData<HC>,
-    phantom_t: PhantomData<T>,
-    phantom_apc: PhantomData<APC>,
+pub struct WinitEventLoop<ET: 'static> {
+    event_loop: RawWinitEventLoop<ET>,
 }
 
-impl<S: Scheduler, HC: HttpClient, T: Transferables, APC: AsyncProcedureCall<T, HC>> Environment
-    for WinitEnvironment<S, HC, T, APC>
-{
-    type MapWindowConfig = WinitMapWindowConfig;
-    type AsyncProcedureCall = APC;
-    type Scheduler = S;
-    type HttpClient = HC;
-    type Transferables = T;
-}
+impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
+    type EventLoopProxy = WinitEventLoopProxy<ET>;
 
-///Main (platform-specific) main loop which handles:
-///* Input (Mouse/Keyboard)
-///* Platform Events like suspend/resume
-///* Render a new frame
-impl<E: Environment> EventLoop<E> for WinitMapWindow
-where
-    E::MapWindowConfig: MapWindowConfig<MapWindow = WinitMapWindow>,
-{
-    fn run(
+    fn run<E>(
         mut self,
-        map_schedule: Rc<RefCell<InteractiveMapSchedule<E>>>,
+        mut window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
+        mut map: Map<E>,
         max_frames: Option<u64>,
-    ) {
+    ) where
+        E: Environment,
+        <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
+    {
         let mut last_render_time = Instant::now();
         let mut current_frame: u64 = 0;
 
         let mut input_controller = InputController::new(0.2, 100.0, 0.1);
 
-        self.take_event_loop()
-            .unwrap()
-            .run(move |event, _, control_flow| {
-                let mut map_schedule = map_schedule.deref().borrow_mut();
-
+        self.event_loop
+            .run(move |event, window_target, control_flow| {
                 #[cfg(target_os = "android")]
-                if !map_schedule.is_initialized() && event == Event::Resumed {
+                if !map.is_initialized() && event == Event::Resumed {
                     use tokio::{runtime::Handle, task};
 
                     task::block_in_place(|| {
                         Handle::current().block_on(async {
-                            map_schedule.late_init().await;
+                            map.late_init().await;
                         })
                     });
                     return;
                 }
 
                 match event {
-                Event::DeviceEvent {
-                    ref event,
-                    .. // We're not using device_id currently
-                } => {
-                    input_controller.device_input(event);
-                }
+                    Event::DeviceEvent {
+                        ref event,
+                        .. // We're not using device_id currently
+                    } => {
+                        input_controller.device_input(event);
+                    }
 
-                Event::WindowEvent {
-                    ref event,
-                    window_id,
-                } if window_id == self.inner().id() => {
-                    if !input_controller.window_input(event) {
-                        match event {
-                            WindowEvent::CloseRequested
-                            | WindowEvent::KeyboardInput {
-                                input:
-                                KeyboardInput {
-                                    state: ElementState::Pressed,
-                                    virtual_keycode: Some(VirtualKeyCode::Escape),
+                    Event::WindowEvent {
+                        ref event,
+                        window_id,
+                    } if window_id == window.id().into() => {
+                        if !input_controller.window_input(event) {
+                            match event {
+                                WindowEvent::CloseRequested
+                                | WindowEvent::KeyboardInput {
+                                    input:
+                                    KeyboardInput {
+                                        state: ElementState::Pressed,
+                                        virtual_keycode: Some(VirtualKeyCode::Escape),
+                                        ..
+                                    },
                                     ..
-                                },
-                                ..
-                            } => *control_flow = ControlFlow::Exit,
-                            WindowEvent::Resized(physical_size) => {
-                                map_schedule.resize(physical_size.width, physical_size.height);
+                                } => *control_flow = ControlFlow::Exit,
+                                WindowEvent::Resized(physical_size) => {
+                                    // FIXME map.resize(physical_size.width, physical_size.height);
+                                }
+                                WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
+                                    // FIXME map.resize(new_inner_size.width, new_inner_size.height);
+                                }
+                                _ => {}
                             }
-                            WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                                map_schedule.resize(new_inner_size.width, new_inner_size.height);
-                            }
-                            _ => {}
                         }
                     }
-                }
-                Event::RedrawRequested(_) => {
-                    let now = Instant::now();
-                    let dt = now - last_render_time;
-                    last_render_time = now;
+                    Event::RedrawRequested(_) => {
+                        let now = Instant::now();
+                        let dt = now - last_render_time;
+                        last_render_time = now;
 
-                    input_controller.update_state(map_schedule.view_state_mut(), dt);
+                        // FIXME input_controller.update_state(map.view_state_mut(), dt);
 
-                    match map_schedule.update_and_redraw() {
-                        Ok(_) => {}
-                        Err(Error::Render(e)) => {
-                            eprintln!("{}", e);
-                            if e.should_exit() {
+                        match map.run_schedule() {
+                            Ok(_) => {}
+                            Err(Error::Render(e)) => {
+                                eprintln!("{}", e);
+                                if e.should_exit() {
+                                    *control_flow = ControlFlow::Exit;
+                                }
+                            }
+                            e => eprintln!("{:?}", e)
+                        };
+
+                        if let Some(max_frames) = max_frames {
+                            if current_frame >= max_frames {
+                                log::info!("Exiting because maximum frames reached.");
                                 *control_flow = ControlFlow::Exit;
                             }
-                        }
-                        e => eprintln!("{:?}", e)
-                    };
 
-                    if let Some(max_frames) = max_frames {
-                        if current_frame >= max_frames {
-                            log::info!("Exiting because maximum frames reached.");
-                            *control_flow = ControlFlow::Exit;
+                            current_frame += 1;
                         }
-
-                        current_frame += 1;
                     }
+                    Event::Suspended => {
+                        // FIXME unimplemented!()
+                    }
+                    Event::Resumed => {
+                        // FIXME unimplemented!()
+                    }
+                    Event::MainEventsCleared => {
+                        // RedrawRequested will only trigger once, unless we manually
+                        // request it.
+                        window.request_redraw();
+                    }
+                    _ => {}
                 }
-                Event::Suspended => {
-                    map_schedule.suspend();
-                }
-                Event::Resumed => {
-                    map_schedule.resume(&self);
-                }
-                Event::MainEventsCleared => {
-                    // RedrawRequested will only trigger once, unless we manually
-                    // request it.
-                    self.inner().request_redraw();
-                }
-                _ => {}
-            }
             });
     }
+
+    fn create_proxy(&self) -> Self::EventLoopProxy {
+        WinitEventLoopProxy {
+            proxy: self.event_loop.create_proxy(),
+        }
+    }
+}
+pub struct WinitEventLoopProxy<ET: 'static> {
+    proxy: RawEventLoopProxy<ET>,
+}
+
+impl<ET: 'static> EventLoopProxy<ET> for WinitEventLoopProxy<ET> {
+    fn send_event(&self, event: ET) {
+        self.proxy.send_event(event); // FIXME: Handle unwrap
+    }
+}
+
+pub struct WinitEnvironment<S: Scheduler, HC: HttpClient, APC: AsyncProcedureCall<HC>, ET> {
+    phantom_s: PhantomData<S>,
+    phantom_hc: PhantomData<HC>,
+    phantom_apc: PhantomData<APC>,
+    phantom_et: PhantomData<ET>,
+}
+
+impl<S: Scheduler, HC: HttpClient, APC: AsyncProcedureCall<HC>, ET: 'static> Environment
+    for WinitEnvironment<S, HC, APC, ET>
+{
+    type MapWindowConfig = WinitMapWindowConfig<ET>;
+    type AsyncProcedureCall = APC;
+    type Scheduler = S;
+    type HttpClient = HC;
 }
diff --git a/maplibre-winit/src/winit/noweb.rs b/maplibre-winit/src/winit/noweb.rs
index 41820e53..6e6a3761 100644
--- a/maplibre-winit/src/winit/noweb.rs
+++ b/maplibre-winit/src/winit/noweb.rs
@@ -3,18 +3,23 @@
 //! * Platform Events like suspend/resume
 //! * Render a new frame
 
+use maplibre::event_loop::EventLoop;
+use maplibre::headless::map::HeadlessMap;
+use maplibre::kernel::{Kernel, KernelBuilder};
+use maplibre::map::Map;
+use maplibre::render::builder::RenderBuilder;
+use maplibre::style::Style;
 use maplibre::{
     io::apc::SchedulerAsyncProcedureCall,
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
     window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
-    MapBuilder,
 };
 use winit::window::WindowBuilder;
 
-use super::{WinitEventLoop, WinitMapWindow, WinitMapWindowConfig, WinitWindow};
-use crate::winit::WinitEnvironment;
+use super::{RawWinitEventLoop, RawWinitWindow, WinitMapWindow, WinitMapWindowConfig};
+use crate::winit::{WinitEnvironment, WinitEventLoop};
 
-impl MapWindow for WinitMapWindow {
+impl<T> MapWindow for WinitMapWindow<T> {
     fn size(&self) -> WindowSize {
         let size = self.window.inner_size();
         #[cfg(target_os = "android")]
@@ -29,27 +34,37 @@ impl MapWindow for WinitMapWindow {
         window_size
     }
 }
-impl HeadedMapWindow for WinitMapWindow {
-    type RawWindow = WinitWindow;
+impl<T> HeadedMapWindow for WinitMapWindow<T> {
+    type RawWindow = RawWinitWindow;
 
-    fn inner(&self) -> &Self::RawWindow {
+    fn raw(&self) -> &Self::RawWindow {
         &self.window
     }
+
+    fn request_redraw(&self) {
+        self.window.request_redraw()
+    }
+
+    fn id(&self) -> u64 {
+        self.window.id().into()
+    }
 }
 
-impl MapWindowConfig for WinitMapWindowConfig {
-    type MapWindow = WinitMapWindow;
+impl<ET: 'static> MapWindowConfig for WinitMapWindowConfig<ET> {
+    type MapWindow = WinitMapWindow<ET>;
 
     fn create(&self) -> Self::MapWindow {
-        let event_loop = WinitEventLoop::new();
+        let raw_event_loop = winit::event_loop::EventLoopBuilder::<ET>::with_user_event().build();
         let window = WindowBuilder::new()
             .with_title(&self.title)
-            .build(&event_loop)
+            .build(&raw_event_loop)
             .unwrap();
 
         Self::MapWindow {
             window,
-            event_loop: Some(event_loop),
+            event_loop: Some(WinitEventLoop {
+                event_loop: raw_event_loop,
+            }),
         }
     }
 }
@@ -57,7 +72,7 @@ impl MapWindowConfig for WinitMapWindowConfig {
 pub fn run_headed_map(cache_path: Option<String>) {
     run_multithreaded(async {
         let client = ReqwestHttpClient::new(cache_path);
-        MapBuilder::<WinitEnvironment<_, _, _, SchedulerAsyncProcedureCall<_, _>>>::new()
+        let kernel: Kernel<WinitEnvironment<_, _, _, ()>> = KernelBuilder::new()
             .with_map_window_config(WinitMapWindowConfig::new("maplibre".to_string()))
             .with_http_client(client.clone())
             .with_apc(SchedulerAsyncProcedureCall::new(
@@ -65,9 +80,21 @@ pub fn run_headed_map(cache_path: Option<String>) {
                 TokioScheduler::new(),
             ))
             .with_scheduler(TokioScheduler::new())
+            .build();
+
+        let uninitialized = RenderBuilder::new()
             .build()
-            .initialize()
+            .initialize_with(&kernel)
             .await
-            .run()
+            .expect("Failed to initialize renderer");
+        let result = uninitialized.unwarp();
+
+        let mut window = result.window;
+        let renderer = result.renderer;
+        window.event_loop.take().unwrap().run(
+            window,
+            Map::new(Style::default(), kernel, renderer).unwrap(),
+            None,
+        )
     })
 }
diff --git a/maplibre-winit/src/winit/web.rs b/maplibre-winit/src/winit/web.rs
index 9fea4848..44bfeaf4 100644
--- a/maplibre-winit/src/winit/web.rs
+++ b/maplibre-winit/src/winit/web.rs
@@ -1,13 +1,13 @@
 use maplibre::window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize};
 use winit::{platform::web::WindowBuilderExtWebSys, window::WindowBuilder};
 
-use super::{WinitEventLoop, WinitMapWindow, WinitMapWindowConfig, WinitWindow};
+use super::{RawWinitEventLoop, RawWinitWindow, WinitMapWindow, WinitMapWindowConfig};
 
 impl MapWindowConfig for WinitMapWindowConfig {
     type MapWindow = WinitMapWindow;
 
     fn create(&self) -> Self::MapWindow {
-        let event_loop = WinitEventLoop::new();
+        let event_loop = RawWinitEventLoop::new();
 
         let window: winit::window::Window = WindowBuilder::new()
             .with_canvas(Some(get_canvas(&self.canvas_id)))
@@ -31,9 +31,9 @@ impl MapWindow for WinitMapWindow {
     }
 }
 impl HeadedMapWindow for WinitMapWindow {
-    type RawWindow = WinitWindow;
+    type RawWindow = RawWinitWindow;
 
-    fn inner(&self) -> &Self::RawWindow {
+    fn raw(&self) -> &Self::RawWindow {
         &self.window
     }
 }
diff --git a/maplibre/src/environment.rs b/maplibre/src/environment.rs
index c68b39e9..8002881e 100644
--- a/maplibre/src/environment.rs
+++ b/maplibre/src/environment.rs
@@ -1,3 +1,5 @@
+use crate::event_loop::EventLoopConfig;
+use crate::kernel::Kernel;
 use crate::{
     io::{
         apc::AsyncProcedureCall,
@@ -13,63 +15,7 @@ use crate::{
 pub trait Environment: 'static {
     type MapWindowConfig: MapWindowConfig;
 
-    type AsyncProcedureCall: AsyncProcedureCall<Self::Transferables, Self::HttpClient>;
+    type AsyncProcedureCall: AsyncProcedureCall<Self::HttpClient>;
     type Scheduler: Scheduler;
     type HttpClient: HttpClient;
-
-    type Transferables: Transferables;
-}
-
-pub struct Kernel<E: Environment> {
-    pub map_window_config: E::MapWindowConfig,
-    pub apc: E::AsyncProcedureCall,
-    pub scheduler: E::Scheduler,
-    pub source_client: SourceClient<E::HttpClient>,
-}
-
-pub struct KernelBuilder<E: Environment> {
-    map_window_config: Option<E::MapWindowConfig>,
-    apc: Option<E::AsyncProcedureCall>,
-    scheduler: Option<E::Scheduler>,
-    http_client: Option<E::HttpClient>,
-}
-
-impl<E: Environment> KernelBuilder<E> {
-    pub fn new() -> Self {
-        Self {
-            scheduler: None,
-            apc: None,
-            http_client: None,
-            map_window_config: None,
-        }
-    }
-
-    pub fn with_map_window_config(mut self, map_window_config: E::MapWindowConfig) -> Self {
-        self.map_window_config = Some(map_window_config);
-        self
-    }
-
-    pub fn with_scheduler(mut self, scheduler: E::Scheduler) -> Self {
-        self.scheduler = Some(scheduler);
-        self
-    }
-
-    pub fn with_apc(mut self, apc: E::AsyncProcedureCall) -> Self {
-        self.apc = Some(apc);
-        self
-    }
-
-    pub fn with_http_client(mut self, http_client: E::HttpClient) -> Self {
-        self.http_client = Some(http_client);
-        self
-    }
-
-    pub fn build(self) -> Kernel<E> {
-        Kernel {
-            scheduler: self.scheduler.unwrap(), // TODO: Remove unwrap
-            apc: self.apc.unwrap(),             // TODO: Remove unwrap
-            source_client: SourceClient::new(HttpSourceClient::new(self.http_client.unwrap())), // TODO: Remove unwrap
-            map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
-        }
-    }
 }
diff --git a/maplibre/src/event_loop.rs b/maplibre/src/event_loop.rs
new file mode 100644
index 00000000..c7614118
--- /dev/null
+++ b/maplibre/src/event_loop.rs
@@ -0,0 +1,29 @@
+use crate::environment::Environment;
+use crate::map::Map;
+use crate::window::{HeadedMapWindow, MapWindowConfig};
+
+pub trait EventLoopConfig {
+    type EventType: 'static;
+    type EventLoopProxy: EventLoopProxy<Self::EventType>;
+
+    fn create_proxy() -> Self::EventLoopProxy;
+}
+
+pub trait EventLoopProxy<T: 'static> {
+    fn send_event(&self, event: T);
+}
+
+pub trait EventLoop<T: 'static> {
+    type EventLoopProxy: EventLoopProxy<T>;
+
+    fn run<E>(
+        self,
+        window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
+        map: Map<E>,
+        max_frames: Option<u64>,
+    ) where
+        E: Environment,
+        <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow;
+
+    fn create_proxy(&self) -> Self::EventLoopProxy;
+}
diff --git a/maplibre/src/headless/environment.rs b/maplibre/src/headless/environment.rs
index 6efb78a8..5d48537e 100644
--- a/maplibre/src/headless/environment.rs
+++ b/maplibre/src/headless/environment.rs
@@ -1,7 +1,6 @@
 use crate::environment::Environment;
 use crate::headless::window::HeadlessMapWindowConfig;
 use crate::io::apc::SchedulerAsyncProcedureCall;
-use crate::io::transferables::DefaultTransferables;
 use crate::platform::http_client::ReqwestHttpClient;
 use crate::platform::scheduler::TokioScheduler;
 
@@ -12,5 +11,4 @@ impl Environment for HeadlessEnvironment {
     type AsyncProcedureCall = SchedulerAsyncProcedureCall<Self::HttpClient, Self::Scheduler>;
     type Scheduler = TokioScheduler;
     type HttpClient = ReqwestHttpClient;
-    type Transferables = DefaultTransferables;
 }
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index 33ec7861..eedc27ce 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -1,9 +1,9 @@
 use crate::io::pipeline::Processable;
+use crate::kernel::Kernel;
 use crate::render::builder::UninitializedRenderer;
 use crate::{
     context::MapContext,
     coords::{WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
-    environment::Kernel,
     error::Error,
     headless::{
         environment::HeadlessEnvironment, graph_node::CopySurfaceBufferNode,
diff --git a/maplibre/src/io/apc.rs b/maplibre/src/io/apc.rs
index de44408f..9761b2ba 100644
--- a/maplibre/src/io/apc.rs
+++ b/maplibre/src/io/apc.rs
@@ -48,10 +48,11 @@ pub type AsyncProcedureFuture = Pin<Box<(dyn Future<Output = ()> + 'static)>>;
 
 pub type AsyncProcedure<C> = fn(input: Input, context: C) -> AsyncProcedureFuture;
 
-pub trait AsyncProcedureCall<T: Transferables, HC: HttpClient>: 'static {
-    type Context: Context<T, HC> + Send;
+pub trait AsyncProcedureCall<HC: HttpClient>: 'static {
+    type Context: Context<Self::Transferables, HC> + Send;
+    type Transferables: Transferables;
 
-    fn receive(&mut self) -> Option<Message<T>>;
+    fn receive(&self) -> Option<Message<Self::Transferables>>;
 
     fn schedule(&self, input: Input, procedure: AsyncProcedure<Self::Context>);
 }
@@ -91,12 +92,11 @@ impl<HC: HttpClient, S: Scheduler> SchedulerAsyncProcedureCall<HC, S> {
     }
 }
 
-impl<HC: HttpClient, S: Scheduler> AsyncProcedureCall<DefaultTransferables, HC>
-    for SchedulerAsyncProcedureCall<HC, S>
-{
-    type Context = SchedulerContext<DefaultTransferables, HC>;
+impl<HC: HttpClient, S: Scheduler> AsyncProcedureCall<HC> for SchedulerAsyncProcedureCall<HC, S> {
+    type Context = SchedulerContext<Self::Transferables, HC>;
+    type Transferables = DefaultTransferables;
 
-    fn receive(&mut self) -> Option<Message<DefaultTransferables>> {
+    fn receive(&self) -> Option<Message<DefaultTransferables>> {
         let transferred = self.channel.1.try_recv().ok()?;
         Some(transferred)
     }
diff --git a/maplibre/src/kernel.rs b/maplibre/src/kernel.rs
new file mode 100644
index 00000000..77065afc
--- /dev/null
+++ b/maplibre/src/kernel.rs
@@ -0,0 +1,56 @@
+use crate::environment::Environment;
+use crate::io::source_client::{HttpSourceClient, SourceClient};
+
+pub struct Kernel<E: Environment> {
+    pub map_window_config: E::MapWindowConfig,
+    pub apc: E::AsyncProcedureCall,
+    pub scheduler: E::Scheduler,
+    pub source_client: SourceClient<E::HttpClient>,
+}
+
+pub struct KernelBuilder<E: Environment> {
+    map_window_config: Option<E::MapWindowConfig>,
+    apc: Option<E::AsyncProcedureCall>,
+    scheduler: Option<E::Scheduler>,
+    http_client: Option<E::HttpClient>,
+}
+
+impl<E: Environment> KernelBuilder<E> {
+    pub fn new() -> Self {
+        Self {
+            scheduler: None,
+            apc: None,
+            http_client: None,
+            map_window_config: None,
+        }
+    }
+
+    pub fn with_map_window_config(mut self, map_window_config: E::MapWindowConfig) -> Self {
+        self.map_window_config = Some(map_window_config);
+        self
+    }
+
+    pub fn with_scheduler(mut self, scheduler: E::Scheduler) -> Self {
+        self.scheduler = Some(scheduler);
+        self
+    }
+
+    pub fn with_apc(mut self, apc: E::AsyncProcedureCall) -> Self {
+        self.apc = Some(apc);
+        self
+    }
+
+    pub fn with_http_client(mut self, http_client: E::HttpClient) -> Self {
+        self.http_client = Some(http_client);
+        self
+    }
+
+    pub fn build(self) -> Kernel<E> {
+        Kernel {
+            scheduler: self.scheduler.unwrap(), // TODO: Remove unwrap
+            apc: self.apc.unwrap(),             // TODO: Remove unwrap
+            source_client: SourceClient::new(HttpSourceClient::new(self.http_client.unwrap())), // TODO: Remove unwrap
+            map_window_config: self.map_window_config.unwrap(), // TODO: Remove unwrap
+        }
+    }
+}
diff --git a/maplibre/src/lib.rs b/maplibre/src/lib.rs
index 2f702f18..73b8358c 100644
--- a/maplibre/src/lib.rs
+++ b/maplibre/src/lib.rs
@@ -42,6 +42,8 @@ pub mod environment;
 // Used for benchmarking
 pub mod benchmarking;
 
+pub mod event_loop;
+pub mod kernel;
 pub mod map;
 pub mod world;
 
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index 4a71ff99..bb51caff 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -1,15 +1,18 @@
 use crate::context::MapContext;
 use crate::coords::{LatLon, WorldCoords, Zoom, TILE_SIZE};
-use crate::environment::{Environment, Kernel};
+use crate::environment::Environment;
 use crate::error::Error;
 use crate::headless::environment::HeadlessEnvironment;
+use crate::kernel::Kernel;
 use crate::render::{create_default_render_graph, register_default_render_stages, Renderer};
 use crate::schedule::{Schedule, Stage};
+use crate::stages::register_stages;
 use crate::style::Style;
 use crate::world::World;
+use std::rc::Rc;
 
 pub struct Map<E: Environment> {
-    kernel: Kernel<E>,
+    kernel: Rc<Kernel<E>>,
     schedule: Schedule,
     map_context: MapContext,
 }
@@ -31,6 +34,10 @@ impl<E: Environment> Map<E> {
         let graph = create_default_render_graph().unwrap(); // TODO: Remove unwrap
         register_default_render_stages(graph, &mut schedule);
 
+        let kernel = Rc::new(kernel);
+
+        register_stages::<E>(&mut schedule, kernel.clone());
+
         Ok(Self {
             kernel,
             map_context: MapContext {
diff --git a/maplibre/src/render/builder.rs b/maplibre/src/render/builder.rs
index 355d9c99..5ef2fff2 100644
--- a/maplibre/src/render/builder.rs
+++ b/maplibre/src/render/builder.rs
@@ -1,5 +1,5 @@
-use crate::environment::Kernel;
 use crate::error::Error;
+use crate::kernel::Kernel;
 use crate::{
     environment::Environment,
     render::{
@@ -9,17 +9,20 @@ use crate::{
     style::Style,
     window::{HeadedMapWindow, MapWindow, MapWindowConfig},
 };
+use std::marker::PhantomData;
 
-pub struct RenderBuilder {
+pub struct RenderBuilder<MWC: MapWindowConfig> {
     wgpu_settings: Option<WgpuSettings>,
     renderer_settings: Option<RendererSettings>,
+    phatom_mwc: PhantomData<MWC>,
 }
 
-impl RenderBuilder {
+impl<MWC: MapWindowConfig> RenderBuilder<MWC> {
     pub fn new() -> Self {
         Self {
             wgpu_settings: None,
             renderer_settings: None,
+            phatom_mwc: Default::default(),
         }
     }
 
@@ -33,21 +36,22 @@ impl RenderBuilder {
         self
     }
 
-    pub fn build(self) -> UninitializedRenderer {
+    pub fn build(self) -> UninitializedRenderer<MWC> {
         UninitializedRenderer {
+            window: None,
             wgpu_settings: self.wgpu_settings.unwrap_or_default(),
             renderer_settings: self.renderer_settings.unwrap_or_default(),
         }
     }
 }
 
-pub enum InitializationResult {
-    Initialized(Renderer),
-    Uninizalized(UninitializedRenderer),
+pub enum InitializationResult<MWC: MapWindowConfig> {
+    Initialized(InitializedRenderer<MWC>),
+    Uninizalized(UninitializedRenderer<MWC>),
 }
 
-impl InitializationResult {
-    pub fn unwarp(self) -> Renderer {
+impl<MWC: MapWindowConfig> InitializationResult<MWC> {
+    pub fn unwarp(self) -> InitializedRenderer<MWC> {
         match self {
             InitializationResult::Initialized(renderer) => renderer,
             InitializationResult::Uninizalized(_) => panic!("Renderer is not initialized"),
@@ -55,55 +59,55 @@ impl InitializationResult {
     }
 }
 
-pub struct UninitializedRenderer {
+pub struct UninitializedRenderer<MWC: MapWindowConfig> {
+    window: Option<MWC::MapWindow>,
     wgpu_settings: WgpuSettings,
     renderer_settings: RendererSettings,
 }
 
-impl UninitializedRenderer {
+impl<MWC: MapWindowConfig> UninitializedRenderer<MWC>
+where
+    MWC::MapWindow: MapWindow + HeadedMapWindow,
+{
     /// Initializes the whole rendering pipeline for the given configuration.
     /// Returns the initialized map, ready to be run.
-    async fn initialize<MWC: MapWindowConfig>(
-        self,
-        map_window_config: &MWC,
-    ) -> Result<InitializationResult, Error>
-    where
-        MWC::MapWindow: MapWindow + HeadedMapWindow,
-    {
+    async fn initialize(self, map_window_config: &MWC) -> Result<InitializationResult<MWC>, Error> {
         let window = map_window_config.create();
 
         #[cfg(target_os = "android")]
-        let renderer = Ok(InitializationResult::Uninizalized(self));
+        {
+            Ok(InitializationResult::Uninizalized(self))
+        }
+
         #[cfg(not(target_os = "android"))]
-        let renderer = Ok(InitializationResult::Initialized(
-            Renderer::initialize(
+        {
+            let renderer = Renderer::initialize(
                 &window,
                 self.wgpu_settings.clone(),
                 self.renderer_settings.clone(),
             )
-            .await?,
-        ));
-
-        renderer
+            .await?;
+            Ok(InitializationResult::Initialized(InitializedRenderer {
+                window,
+                renderer,
+            }))
+        }
     }
 
-    pub async fn initialize_with<E: Environment>(
+    pub async fn initialize_with<E>(
         self,
         kernel: &Kernel<E>,
-    ) -> Result<InitializationResult, Error>
+    ) -> Result<InitializationResult<MWC>, Error>
     where
-        <E::MapWindowConfig as MapWindowConfig>::MapWindow: MapWindow + HeadedMapWindow,
+        E: Environment<MapWindowConfig = MWC>,
     {
         self.initialize(&kernel.map_window_config).await
     }
 }
 
 #[cfg(feature = "headless")]
-impl UninitializedRenderer {
-    async fn initialize_headless<MWC: MapWindowConfig>(
-        self,
-        map_window_config: MWC,
-    ) -> Result<Renderer, Error> {
+impl<MWC: MapWindowConfig> UninitializedRenderer<MWC> {
+    async fn initialize_headless(self, map_window_config: &MWC) -> Result<Renderer, Error> {
         let window = map_window_config.create();
 
         Ok(Renderer::initialize_headless(
@@ -114,13 +118,15 @@ impl UninitializedRenderer {
         .await?)
     }
 
-    pub async fn initialize_headless_with<E: Environment>(
-        self,
-        kernel: &Kernel<E>,
-    ) -> Result<InitializationResult, Error>
+    pub async fn initialize_headless_with<E>(self, kernel: &Kernel<E>) -> Result<Renderer, Error>
     where
-        <E::MapWindowConfig as MapWindowConfig>::MapWindow: MapWindow + HeadedMapWindow,
+        E: Environment<MapWindowConfig = MWC>,
     {
-        self.initialize(&kernel.map_window_config).await
+        self.initialize_headless(&kernel.map_window_config).await
     }
 }
+
+pub struct InitializedRenderer<MWC: MapWindowConfig> {
+    pub window: MWC::MapWindow,
+    pub renderer: Renderer,
+}
diff --git a/maplibre/src/render/camera.rs b/maplibre/src/render/camera.rs
index 989e0e0e..5e7e1e84 100644
--- a/maplibre/src/render/camera.rs
+++ b/maplibre/src/render/camera.rs
@@ -1,6 +1,6 @@
 //! Main camera
 
-use cgmath::{prelude::*, AbsDiffEq, Matrix4, Point2, Point3, Vector2, Vector3, Vector4};
+use cgmath::{prelude::*, AbsDiffEq, Matrix4, Point2, Point3, Rad, Vector2, Vector3, Vector4};
 
 use crate::util::{
     math::{bounds_from_points, Aabb2, Aabb3, Plane},
@@ -68,12 +68,12 @@ impl ModelViewProjection {
 
 #[derive(Debug, Clone)]
 pub struct Camera {
-    pub position: Point3<f64>, // The z axis never changes, the zoom is used instead
-    pub yaw: cgmath::Rad<f64>,
-    pub pitch: cgmath::Rad<f64>,
+    position: Point3<f64>, // The z axis never changes, the zoom is used instead
+    yaw: cgmath::Rad<f64>,
+    pitch: cgmath::Rad<f64>,
 
-    pub width: f64,
-    pub height: f64,
+    width: f64,
+    height: f64,
 }
 
 impl SignificantlyDifferent for Camera {
@@ -103,6 +103,14 @@ impl Camera {
         }
     }
 
+    pub fn move_to(&mut self, point: Point3<f64>) {
+        self.position = point;
+    }
+
+    pub fn move_relative(&mut self, delta: Vector3<f64>) {
+        self.position += delta;
+    }
+
     pub fn resize(&mut self, width: u32, height: u32) {
         self.width = width as f64;
         self.height = height as f64;
@@ -347,6 +355,26 @@ impl Camera {
             Point2::new(max_x, max_y),
         ))
     }
+
+    pub fn position(&self) -> Point3<f64> {
+        self.position
+    }
+
+    pub fn yaw(&self) -> cgmath::Rad<f64> {
+        self.yaw
+    }
+
+    pub fn yaw_self<P: Into<Rad<f64>>>(&mut self, delta: P) {
+        self.yaw += delta.into();
+    }
+
+    pub fn pitch(&self) -> cgmath::Rad<f64> {
+        self.pitch
+    }
+
+    pub fn pitch_self<P: Into<Rad<f64>>>(&mut self, delta: P) {
+        self.pitch += delta.into();
+    }
 }
 
 pub struct Perspective {
diff --git a/maplibre/src/render/stages/upload_stage.rs b/maplibre/src/render/stages/upload_stage.rs
index 2684fc87..116b4370 100644
--- a/maplibre/src/render/stages/upload_stage.rs
+++ b/maplibre/src/render/stages/upload_stage.rs
@@ -45,7 +45,8 @@ impl Stage for UploadStage {
                 bytemuck::cast_slice(&[ShaderGlobals::new(ShaderCamera::new(
                     view_proj.downcast().into(),
                     view_state
-                        .camera_position()
+                        .camera()
+                        .position()
                         .to_homogeneous()
                         .cast::<f32>()
                         .unwrap() // TODO: Remove unwrap
diff --git a/maplibre/src/stages/mod.rs b/maplibre/src/stages/mod.rs
index 2af6c379..de565d39 100644
--- a/maplibre/src/stages/mod.rs
+++ b/maplibre/src/stages/mod.rs
@@ -10,6 +10,7 @@ use std::{
 use geozero::{mvt::tile, GeozeroDatasource};
 use request_stage::RequestStage;
 
+use crate::kernel::Kernel;
 use crate::{
     coords::{WorldCoords, WorldTileCoords, Zoom, ZoomLevel},
     environment::Environment,
@@ -37,16 +38,9 @@ mod populate_tile_store_stage;
 mod request_stage;
 
 /// Register stages required for requesting and preparing new tiles.
-pub fn register_stages<E: Environment>(
-    schedule: &mut Schedule,
-    http_source_client: HttpSourceClient<E::HttpClient>,
-    apc: Rc<RefCell<E::AsyncProcedureCall>>,
-) {
-    schedule.add_stage(
-        "request",
-        RequestStage::<E>::new(http_source_client, apc.clone()),
-    );
-    schedule.add_stage("populate_tile_store", PopulateTileStore::<E>::new(apc));
+pub fn register_stages<E: Environment>(schedule: &mut Schedule, kernel: Rc<Kernel<E>>) {
+    schedule.add_stage("request", RequestStage::<E>::new(kernel.clone()));
+    schedule.add_stage("populate_tile_store", PopulateTileStore::<E>::new(kernel));
 }
 
 pub struct HeadedPipelineProcessor<T: Transferables, HC: HttpClient, C: Context<T, HC>> {
diff --git a/maplibre/src/stages/populate_tile_store_stage.rs b/maplibre/src/stages/populate_tile_store_stage.rs
index 1c97b8e1..30ce3a9e 100644
--- a/maplibre/src/stages/populate_tile_store_stage.rs
+++ b/maplibre/src/stages/populate_tile_store_stage.rs
@@ -2,6 +2,7 @@
 
 use std::{borrow::BorrowMut, cell::RefCell, ops::Deref, rc::Rc};
 
+use crate::kernel::Kernel;
 use crate::{
     context::MapContext,
     environment::Environment,
@@ -15,12 +16,12 @@ use crate::{
 };
 
 pub struct PopulateTileStore<E: Environment> {
-    apc: Rc<RefCell<E::AsyncProcedureCall>>,
+    kernel: Rc<Kernel<E>>,
 }
 
 impl<E: Environment> PopulateTileStore<E> {
-    pub fn new(apc: Rc<RefCell<E::AsyncProcedureCall>>) -> Self {
-        Self { apc }
+    pub fn new(kernel: Rc<Kernel<E>>) -> Self {
+        Self { kernel }
     }
 }
 
@@ -34,39 +35,37 @@ impl<E: Environment> Stage for PopulateTileStore<E> {
             ..
         }: &mut MapContext,
     ) {
-        if let Ok(mut apc) = self.apc.deref().try_borrow_mut() {
-            if let Some(result) = apc.receive() {
-                match result {
-                    Message::TileTessellated(tranferred) => {
-                        let coords = tranferred.coords();
-                        tile_repository.success(coords);
-                        tracing::trace!("Tile at {} finished loading", coords);
-                        log::warn!("Tile at {} finished loading", coords);
-                    }
-                    // FIXME: deduplicate
-                    Message::UnavailableLayer(tranferred) => {
-                        let layer: StoredLayer = tranferred.to_stored_layer();
-                        tracing::debug!(
-                            "Layer {} at {} reached main thread",
-                            layer.layer_name(),
-                            layer.get_coords()
-                        );
-                        tile_repository.put_tessellated_layer(layer);
-                    }
-                    Message::TessellatedLayer(data) => {
-                        let layer: StoredLayer = data.to_stored_layer();
-                        tracing::debug!(
-                            "Layer {} at {} reached main thread",
-                            layer.layer_name(),
-                            layer.get_coords()
-                        );
-                        log::warn!(
-                            "Layer {} at {} reached main thread",
-                            layer.layer_name(),
-                            layer.get_coords()
-                        );
-                        tile_repository.put_tessellated_layer(layer);
-                    }
+        if let Some(result) = self.kernel.apc.receive() {
+            match result {
+                Message::TileTessellated(tranferred) => {
+                    let coords = tranferred.coords();
+                    tile_repository.success(coords);
+                    tracing::trace!("Tile at {} finished loading", coords);
+                    log::warn!("Tile at {} finished loading", coords);
+                }
+                // FIXME: deduplicate
+                Message::UnavailableLayer(tranferred) => {
+                    let layer: StoredLayer = tranferred.to_stored_layer();
+                    tracing::debug!(
+                        "Layer {} at {} reached main thread",
+                        layer.layer_name(),
+                        layer.get_coords()
+                    );
+                    tile_repository.put_tessellated_layer(layer);
+                }
+                Message::TessellatedLayer(data) => {
+                    let layer: StoredLayer = data.to_stored_layer();
+                    tracing::debug!(
+                        "Layer {} at {} reached main thread",
+                        layer.layer_name(),
+                        layer.get_coords()
+                    );
+                    log::warn!(
+                        "Layer {} at {} reached main thread",
+                        layer.layer_name(),
+                        layer.get_coords()
+                    );
+                    tile_repository.put_tessellated_layer(layer);
                 }
             }
         }
diff --git a/maplibre/src/stages/request_stage.rs b/maplibre/src/stages/request_stage.rs
index c0393db2..681aad32 100644
--- a/maplibre/src/stages/request_stage.rs
+++ b/maplibre/src/stages/request_stage.rs
@@ -12,6 +12,7 @@ use std::{
     str::FromStr,
 };
 
+use crate::kernel::Kernel;
 use crate::{
     context::MapContext,
     coords::{ViewRegion, WorldTileCoords, ZoomLevel},
@@ -33,19 +34,12 @@ use crate::{
 };
 
 pub struct RequestStage<E: Environment> {
-    apc: Rc<RefCell<E::AsyncProcedureCall>>,
-    http_source_client: HttpSourceClient<E::HttpClient>,
+    kernel: Rc<Kernel<E>>,
 }
 
 impl<E: Environment> RequestStage<E> {
-    pub fn new(
-        http_source_client: HttpSourceClient<E::HttpClient>,
-        apc: Rc<RefCell<E::AsyncProcedureCall>>,
-    ) -> Self {
-        Self {
-            apc,
-            http_source_client,
-        }
+    pub fn new(kernel: Rc<Kernel<E>>) -> Self {
+        Self { kernel }
     }
 }
 
@@ -75,7 +69,13 @@ impl<E: Environment> Stage for RequestStage<E> {
     }
 }
 
-pub fn schedule<E: Environment, C: Context<E::Transferables, E::HttpClient>>(
+pub fn schedule<
+    E: Environment,
+    C: Context<
+        <E::AsyncProcedureCall as AsyncProcedureCall<E::HttpClient>>::Transferables,
+        E::HttpClient,
+    >,
+>(
     input: Input,
     context: C,
 ) -> AsyncProcedureFuture {
@@ -106,12 +106,14 @@ pub fn schedule<E: Environment, C: Context<E::Transferables, E::HttpClient>>(
                 log::error!("{:?}", &e);
                 for to_load in &input.layers {
                     tracing::warn!("layer {} at {} unavailable", to_load, coords);
-                    context.send(Message::UnavailableLayer(
-                        <E::Transferables as Transferables>::UnavailableLayer::new(
+                    context.send(
+                        Message::UnavailableLayer(<<E::AsyncProcedureCall as AsyncProcedureCall<
+                            E::HttpClient,
+                        >>::Transferables as Transferables>::UnavailableLayer::new(
                             input.coords,
                             to_load.to_string(),
-                        ),
-                    ));
+                        )),
+                    );
                 }
             }
         }
@@ -156,7 +158,7 @@ impl<E: Environment> RequestStage<E> {
             tile_repository.create_tile(coords);
 
             tracing::info!("new tile request: {}", &coords);
-            self.apc.deref().borrow().schedule(
+            self.kernel.apc.schedule(
                 Input::TileRequest(TileRequest {
                     coords,
                     layers: layers.clone(),
@@ -164,7 +166,6 @@ impl<E: Environment> RequestStage<E> {
                 schedule::<
                     E,
                     <E::AsyncProcedureCall as AsyncProcedureCall<
-                        E::Transferables,
                         E::HttpClient,
                     >>::Context,
                 >,
diff --git a/maplibre/src/window.rs b/maplibre/src/window.rs
index 79eb5bf9..c6955a79 100644
--- a/maplibre/src/window.rs
+++ b/maplibre/src/window.rs
@@ -17,6 +17,11 @@ pub trait HeadedMapWindow: MapWindow {
     type RawWindow: HasRawWindowHandle + HasRawDisplayHandle;
 
     fn raw(&self) -> &Self::RawWindow;
+
+    // TODO: Can we avoid this?
+    fn request_redraw(&self);
+
+    fn id(&self) -> u64;
 }
 
 /// A configuration for a window which determines the corresponding implementation of a
diff --git a/maplibre/src/world.rs b/maplibre/src/world.rs
index 8f056de6..3c81010d 100644
--- a/maplibre/src/world.rs
+++ b/maplibre/src/world.rs
@@ -1,4 +1,5 @@
 use cgmath::{Angle, Point3};
+use std::ops::{Deref, DerefMut};
 
 use crate::{
     coords::{LatLon, ViewRegion, WorldCoords, Zoom, ZoomLevel, TILE_SIZE},
@@ -124,14 +125,23 @@ impl ViewState {
         *self.zoom
     }
 
-    pub fn camera_position(&self) -> Point3<f64> {
-        self.camera.position
-    }
-
     pub fn did_zoom_change(&self) -> bool {
         self.zoom.did_change(0.05)
     }
 
+    pub fn update_zoom(&mut self, new_zoom: Zoom) {
+        *self.zoom = new_zoom;
+        log::info!("zoom: {}", new_zoom);
+    }
+
+    pub fn camera(&self) -> &Camera {
+        self.camera.deref()
+    }
+
+    pub fn camera_mut(&mut self) -> &mut Camera {
+        self.camera.deref_mut()
+    }
+
     pub fn did_camera_change(&self) -> bool {
         self.camera.did_change(0.05)
     }
@@ -140,9 +150,4 @@ impl ViewState {
         self.camera.update_reference();
         self.zoom.update_reference();
     }
-
-    pub fn update_zoom(&mut self, new_zoom: Zoom) {
-        *self.zoom = new_zoom;
-        log::info!("zoom: {}", new_zoom);
-    }
 }

From b863cef5890d1f1f6e1dfa3f491b689aef72014d Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 25 Sep 2022 19:12:20 +0200
Subject: [PATCH 05/31] Fix headless rendering

---
 maplibre-demo/src/headless.rs | 22 ++++++++++++++++++----
 maplibre/src/headless/map.rs  | 17 ++++++++++-------
 2 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/maplibre-demo/src/headless.rs b/maplibre-demo/src/headless.rs
index b7faa1cb..e2af984e 100644
--- a/maplibre-demo/src/headless.rs
+++ b/maplibre-demo/src/headless.rs
@@ -35,7 +35,15 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
         .await
         .expect("Failed to initialize renderer");
 
-    let mut map = HeadlessMap::new(Style::default(), renderer, kernel).unwrap();
+    let style = Style::default();
+
+    let requested_layers = style
+        .layers
+        .iter()
+        .map(|layer| layer.source_layer.as_ref().unwrap().clone())
+        .collect::<Vec<_>>();
+
+    let mut map = HeadlessMap::new(style, renderer, kernel).unwrap();
 
     let tile_limits = google_mercator().tile_limits(
         extent_wgs84_to_merc(&Extent {
@@ -51,10 +59,16 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
         let coords = WorldTileCoords::from((x as i32, y as i32, z.into()));
         println!("Rendering {}", &coords);
         let tile = map
-            .fetch_tile(coords, &["water"])
+            .fetch_tile(
+                coords,
+                &requested_layers
+                    .iter()
+                    .map(|layer| layer.as_str())
+                    .collect::<Vec<_>>(),
+            )
             .await
-            .expect("Failed to fetch and process!");
+            .expect("Failed to fetch and process");
 
-        map.render_tile(tile);
+        map.render_tile(tile).expect("Rendering failed");
     }
 }
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index eedc27ce..8bc80e37 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -46,11 +46,9 @@ impl HeadlessMap {
             window_size,
             WorldCoords::from((TILE_SIZE / 2., TILE_SIZE / 2.)),
             Zoom::default(),
-            cgmath::Deg(110.0),
+            cgmath::Deg(0.0),
         );
 
-        let mut schedule = Schedule::default();
-
         let mut graph = create_default_render_graph()?;
         let draw_graph = graph
             .get_sub_graph_mut(draw_graph::NAME)
@@ -60,8 +58,8 @@ impl HeadlessMap {
             .add_node_edge(draw_graph::node::MAIN_PASS, draw_graph::node::COPY)
             .unwrap(); // TODO: remove unwrap
 
+        let mut schedule = Schedule::default();
         register_default_render_stages(graph, &mut schedule);
-
         schedule.add_stage(
             RenderStageLabel::Cleanup,
             WriteSurfaceBufferStage::default(),
@@ -78,13 +76,17 @@ impl HeadlessMap {
         })
     }
 
-    pub async fn render_tile(&mut self, tile: StoredTile) -> Result<(), Error> {
+    pub fn render_tile(&mut self, tile: StoredTile) -> Result<(), Error> {
         let context = &mut self.map_context;
 
         if let Eventually::Initialized(pool) = context.renderer.state.buffer_pool_mut() {
             pool.clear();
+        } else {
+            // TODO return error
         }
 
+        context.world.tile_repository.clear();
+
         context.world.tile_repository.put_tile(tile);
 
         self.schedule.run(&mut self.map_context);
@@ -103,10 +105,11 @@ impl HeadlessMap {
         let mut pipeline_context = PipelineContext::new(HeadlessPipelineProcessor::default());
         let pipeline = build_vector_tile_pipeline();
 
+        let target_coords = WorldTileCoords::default(); // load to 0,0,0
         pipeline.process(
             (
                 TileRequest {
-                    coords: WorldTileCoords::default(),
+                    coords: target_coords,
                     layers: source_layers
                         .iter()
                         .map(|layer| layer.to_string())
@@ -121,7 +124,7 @@ impl HeadlessMap {
             .take_processor::<HeadlessPipelineProcessor>()
             .expect("Unable to get processor");
 
-        Ok(StoredTile::success(coords, processor.layers))
+        Ok(StoredTile::success(target_coords, processor.layers))
     }
 }
 

From dc3d6576bcc717816d47b508afab1a7dd118e421 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 18:27:26 +0100
Subject: [PATCH 06/31] Fix formatting

---
 maplibre-demo/src/headless.rs                 | 13 +++++-----
 maplibre-winit/src/winit/mod.rs               | 10 +++++---
 maplibre-winit/src/winit/noweb.rs             | 12 ++++-----
 maplibre/src/environment.rs                   |  6 +++--
 maplibre/src/event_loop.rs                    |  8 +++---
 maplibre/src/headless/environment.rs          | 11 ++++----
 maplibre/src/headless/graph_node.rs           |  8 +++---
 maplibre/src/headless/map.rs                  | 15 ++++++-----
 maplibre/src/kernel.rs                        |  6 +++--
 maplibre/src/map.rs                           | 25 +++++++++++--------
 maplibre/src/render/builder.rs                |  7 +++---
 maplibre/src/stages/mod.rs                    |  2 +-
 .../src/stages/populate_tile_store_stage.rs   |  2 +-
 maplibre/src/stages/request_stage.rs          |  2 +-
 maplibre/src/world.rs                         |  3 ++-
 15 files changed, 73 insertions(+), 57 deletions(-)

diff --git a/maplibre-demo/src/headless.rs b/maplibre-demo/src/headless.rs
index e2af984e..abee2cc2 100644
--- a/maplibre-demo/src/headless.rs
+++ b/maplibre-demo/src/headless.rs
@@ -1,14 +1,15 @@
-use maplibre::headless::map::HeadlessMap;
-use maplibre::headless::window::HeadlessMapWindowConfig;
-use maplibre::kernel::KernelBuilder;
-use maplibre::render::builder::RenderBuilder;
-use maplibre::style::Style;
 use maplibre::{
     coords::{LatLon, WorldTileCoords},
     error::Error,
+    headless::{map::HeadlessMap, window::HeadlessMapWindowConfig},
     io::apc::SchedulerAsyncProcedureCall,
+    kernel::KernelBuilder,
     platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
-    render::settings::{RendererSettings, TextureFormat},
+    render::{
+        builder::RenderBuilder,
+        settings::{RendererSettings, TextureFormat},
+    },
+    style::Style,
     util::grid::google_mercator,
     window::WindowSize,
 };
diff --git a/maplibre-winit/src/winit/mod.rs b/maplibre-winit/src/winit/mod.rs
index 97d83847..c705b87a 100644
--- a/maplibre-winit/src/winit/mod.rs
+++ b/maplibre-winit/src/winit/mod.rs
@@ -1,24 +1,26 @@
-use crate::input::{InputController, UpdateState};
+use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
+
 use instant::Instant;
-use maplibre::event_loop::{EventLoop, EventLoopProxy};
-use maplibre::map::Map;
 use maplibre::{
     environment::Environment,
     error::Error,
+    event_loop::{EventLoop, EventLoopProxy},
     io::{
         apc::{AsyncProcedureCall, Message},
         scheduler::Scheduler,
         source_client::HttpClient,
         transferables::{DefaultTransferables, Transferables},
     },
+    map::Map,
     window::{HeadedMapWindow, MapWindowConfig},
 };
-use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
 use winit::{
     event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
     event_loop::ControlFlow,
 };
 
+use crate::input::{InputController, UpdateState};
+
 pub type RawWinitWindow = winit::window::Window;
 pub type RawWinitEventLoop<ET> = winit::event_loop::EventLoop<ET>;
 pub type RawEventLoopProxy<ET> = winit::event_loop::EventLoopProxy<ET>;
diff --git a/maplibre-winit/src/winit/noweb.rs b/maplibre-winit/src/winit/noweb.rs
index 6e6a3761..a2c586f9 100644
--- a/maplibre-winit/src/winit/noweb.rs
+++ b/maplibre-winit/src/winit/noweb.rs
@@ -3,15 +3,15 @@
 //! * Platform Events like suspend/resume
 //! * Render a new frame
 
-use maplibre::event_loop::EventLoop;
-use maplibre::headless::map::HeadlessMap;
-use maplibre::kernel::{Kernel, KernelBuilder};
-use maplibre::map::Map;
-use maplibre::render::builder::RenderBuilder;
-use maplibre::style::Style;
 use maplibre::{
+    event_loop::EventLoop,
+    headless::map::HeadlessMap,
     io::apc::SchedulerAsyncProcedureCall,
+    kernel::{Kernel, KernelBuilder},
+    map::Map,
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
+    render::builder::RenderBuilder,
+    style::Style,
     window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
 };
 use winit::window::WindowBuilder;
diff --git a/maplibre/src/environment.rs b/maplibre/src/environment.rs
index 8002881e..6c496265 100644
--- a/maplibre/src/environment.rs
+++ b/maplibre/src/environment.rs
@@ -1,6 +1,5 @@
-use crate::event_loop::EventLoopConfig;
-use crate::kernel::Kernel;
 use crate::{
+    event_loop::EventLoopConfig,
     io::{
         apc::AsyncProcedureCall,
         scheduler::Scheduler,
@@ -9,6 +8,7 @@ use crate::{
             DefaultTessellatedLayer, DefaultTileTessellated, DefaultUnavailableLayer, Transferables,
         },
     },
+    kernel::Kernel,
     window::MapWindowConfig,
 };
 
@@ -16,6 +16,8 @@ pub trait Environment: 'static {
     type MapWindowConfig: MapWindowConfig;
 
     type AsyncProcedureCall: AsyncProcedureCall<Self::HttpClient>;
+
     type Scheduler: Scheduler;
+
     type HttpClient: HttpClient;
 }
diff --git a/maplibre/src/event_loop.rs b/maplibre/src/event_loop.rs
index c7614118..04089c64 100644
--- a/maplibre/src/event_loop.rs
+++ b/maplibre/src/event_loop.rs
@@ -1,6 +1,8 @@
-use crate::environment::Environment;
-use crate::map::Map;
-use crate::window::{HeadedMapWindow, MapWindowConfig};
+use crate::{
+    environment::Environment,
+    map::Map,
+    window::{HeadedMapWindow, MapWindowConfig},
+};
 
 pub trait EventLoopConfig {
     type EventType: 'static;
diff --git a/maplibre/src/headless/environment.rs b/maplibre/src/headless/environment.rs
index 5d48537e..ba97c9a4 100644
--- a/maplibre/src/headless/environment.rs
+++ b/maplibre/src/headless/environment.rs
@@ -1,8 +1,9 @@
-use crate::environment::Environment;
-use crate::headless::window::HeadlessMapWindowConfig;
-use crate::io::apc::SchedulerAsyncProcedureCall;
-use crate::platform::http_client::ReqwestHttpClient;
-use crate::platform::scheduler::TokioScheduler;
+use crate::{
+    environment::Environment,
+    headless::window::HeadlessMapWindowConfig,
+    io::apc::SchedulerAsyncProcedureCall,
+    platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
+};
 
 pub struct HeadlessEnvironment;
 
diff --git a/maplibre/src/headless/graph_node.rs b/maplibre/src/headless/graph_node.rs
index b050bf30..0dddc953 100644
--- a/maplibre/src/headless/graph_node.rs
+++ b/maplibre/src/headless/graph_node.rs
@@ -1,6 +1,8 @@
-use crate::render::graph::{Node, NodeRunError, RenderContext, RenderGraphContext, SlotInfo};
-use crate::render::resource::Head;
-use crate::render::RenderState;
+use crate::render::{
+    graph::{Node, NodeRunError, RenderContext, RenderGraphContext, SlotInfo},
+    resource::Head,
+    RenderState,
+};
 
 /// Node which copies the contents of the GPU-side texture in [`BufferedTextureHead`] to an
 /// unmapped GPU-side buffer. This buffer will be mapped in
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index 8bc80e37..efee9b3c 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -1,6 +1,5 @@
-use crate::io::pipeline::Processable;
-use crate::kernel::Kernel;
-use crate::render::builder::UninitializedRenderer;
+use std::collections::HashSet;
+
 use crate::{
     context::MapContext,
     coords::{WorldCoords, WorldTileCoords, Zoom, TILE_SIZE},
@@ -10,15 +9,16 @@ use crate::{
         stage::WriteSurfaceBufferStage,
     },
     io::{
-        pipeline::{PipelineContext, PipelineProcessor},
+        pipeline::{PipelineContext, PipelineProcessor, Processable},
         tile_pipelines::build_vector_tile_pipeline,
         tile_repository::{StoredLayer, StoredTile, TileStatus},
         RawLayer, TileRequest,
     },
+    kernel::Kernel,
     render::{
-        create_default_render_graph, draw_graph, error::RenderError, eventually::Eventually,
-        register_default_render_stages, resource::Head, stages::RenderStageLabel, Renderer,
-        ShaderVertex,
+        builder::UninitializedRenderer, create_default_render_graph, draw_graph,
+        error::RenderError, eventually::Eventually, register_default_render_stages, resource::Head,
+        stages::RenderStageLabel, Renderer, ShaderVertex,
     },
     schedule::{Schedule, Stage},
     style::Style,
@@ -26,7 +26,6 @@ use crate::{
     window::WindowSize,
     world::World,
 };
-use std::collections::HashSet;
 
 pub struct HeadlessMap {
     kernel: Kernel<HeadlessEnvironment>,
diff --git a/maplibre/src/kernel.rs b/maplibre/src/kernel.rs
index 77065afc..c16ac33d 100644
--- a/maplibre/src/kernel.rs
+++ b/maplibre/src/kernel.rs
@@ -1,5 +1,7 @@
-use crate::environment::Environment;
-use crate::io::source_client::{HttpSourceClient, SourceClient};
+use crate::{
+    environment::Environment,
+    io::source_client::{HttpSourceClient, SourceClient},
+};
 
 pub struct Kernel<E: Environment> {
     pub map_window_config: E::MapWindowConfig,
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index bb51caff..d6bef2b9 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -1,16 +1,19 @@
-use crate::context::MapContext;
-use crate::coords::{LatLon, WorldCoords, Zoom, TILE_SIZE};
-use crate::environment::Environment;
-use crate::error::Error;
-use crate::headless::environment::HeadlessEnvironment;
-use crate::kernel::Kernel;
-use crate::render::{create_default_render_graph, register_default_render_stages, Renderer};
-use crate::schedule::{Schedule, Stage};
-use crate::stages::register_stages;
-use crate::style::Style;
-use crate::world::World;
 use std::rc::Rc;
 
+use crate::{
+    context::MapContext,
+    coords::{LatLon, WorldCoords, Zoom, TILE_SIZE},
+    environment::Environment,
+    error::Error,
+    headless::environment::HeadlessEnvironment,
+    kernel::Kernel,
+    render::{create_default_render_graph, register_default_render_stages, Renderer},
+    schedule::{Schedule, Stage},
+    stages::register_stages,
+    style::Style,
+    world::World,
+};
+
 pub struct Map<E: Environment> {
     kernel: Rc<Kernel<E>>,
     schedule: Schedule,
diff --git a/maplibre/src/render/builder.rs b/maplibre/src/render/builder.rs
index 5ef2fff2..f2828f77 100644
--- a/maplibre/src/render/builder.rs
+++ b/maplibre/src/render/builder.rs
@@ -1,7 +1,9 @@
-use crate::error::Error;
-use crate::kernel::Kernel;
+use std::marker::PhantomData;
+
 use crate::{
     environment::Environment,
+    error::Error,
+    kernel::Kernel,
     render::{
         settings::{RendererSettings, WgpuSettings},
         Renderer,
@@ -9,7 +11,6 @@ use crate::{
     style::Style,
     window::{HeadedMapWindow, MapWindow, MapWindowConfig},
 };
-use std::marker::PhantomData;
 
 pub struct RenderBuilder<MWC: MapWindowConfig> {
     wgpu_settings: Option<WgpuSettings>,
diff --git a/maplibre/src/stages/mod.rs b/maplibre/src/stages/mod.rs
index de565d39..14c45d4b 100644
--- a/maplibre/src/stages/mod.rs
+++ b/maplibre/src/stages/mod.rs
@@ -10,7 +10,6 @@ use std::{
 use geozero::{mvt::tile, GeozeroDatasource};
 use request_stage::RequestStage;
 
-use crate::kernel::Kernel;
 use crate::{
     coords::{WorldCoords, WorldTileCoords, Zoom, ZoomLevel},
     environment::Environment,
@@ -28,6 +27,7 @@ use crate::{
         },
         TileRequest,
     },
+    kernel::Kernel,
     render::ShaderVertex,
     schedule::Schedule,
     stages::populate_tile_store_stage::PopulateTileStore,
diff --git a/maplibre/src/stages/populate_tile_store_stage.rs b/maplibre/src/stages/populate_tile_store_stage.rs
index 30ce3a9e..c5c4b2c4 100644
--- a/maplibre/src/stages/populate_tile_store_stage.rs
+++ b/maplibre/src/stages/populate_tile_store_stage.rs
@@ -2,7 +2,6 @@
 
 use std::{borrow::BorrowMut, cell::RefCell, ops::Deref, rc::Rc};
 
-use crate::kernel::Kernel;
 use crate::{
     context::MapContext,
     environment::Environment,
@@ -11,6 +10,7 @@ use crate::{
         tile_repository::StoredLayer,
         transferables::{TessellatedLayer, TileTessellated, UnavailableLayer},
     },
+    kernel::Kernel,
     schedule::Stage,
     world::World,
 };
diff --git a/maplibre/src/stages/request_stage.rs b/maplibre/src/stages/request_stage.rs
index 681aad32..3c8ce95f 100644
--- a/maplibre/src/stages/request_stage.rs
+++ b/maplibre/src/stages/request_stage.rs
@@ -12,7 +12,6 @@ use std::{
     str::FromStr,
 };
 
-use crate::kernel::Kernel;
 use crate::{
     context::MapContext,
     coords::{ViewRegion, WorldTileCoords, ZoomLevel},
@@ -27,6 +26,7 @@ use crate::{
         transferables::{Transferables, UnavailableLayer},
         TileRequest,
     },
+    kernel::Kernel,
     schedule::Stage,
     stages::HeadedPipelineProcessor,
     style::Style,
diff --git a/maplibre/src/world.rs b/maplibre/src/world.rs
index 3c81010d..42f5cb78 100644
--- a/maplibre/src/world.rs
+++ b/maplibre/src/world.rs
@@ -1,6 +1,7 @@
-use cgmath::{Angle, Point3};
 use std::ops::{Deref, DerefMut};
 
+use cgmath::{Angle, Point3};
+
 use crate::{
     coords::{LatLon, ViewRegion, WorldCoords, Zoom, ZoomLevel, TILE_SIZE},
     io::tile_repository::TileRepository,

From d8e1e6a9a8ff7c7f082f776646659a845fd72235 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 18:32:27 +0100
Subject: [PATCH 07/31] Ignore some directories

---
 .idea/maplibre-rs.iml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.idea/maplibre-rs.iml b/.idea/maplibre-rs.iml
index 339ac96a..24119645 100644
--- a/.idea/maplibre-rs.iml
+++ b/.idea/maplibre-rs.iml
@@ -20,7 +20,8 @@
       <excludeFolder url="file://$MODULE_DIR$/target" />
       <excludeFolder url="file://$MODULE_DIR$/docs/book" />
       <excludeFolder url="file://$MODULE_DIR$/web/lib/.parcel-cache" />
-      <excludeFolder url="file://$MODULE_DIR$/web/lib/src/wasm-pack" />
+      <excludeFolder url="file://$MODULE_DIR$/web/lib/src/wasm" />
+      <excludeFolder url="file://$MODULE_DIR$/web/lib/dist" />
       <excludeFolder url="file://$MODULE_DIR$/maplibre-cache" />
     </content>
     <orderEntry type="inheritedJdk" />

From 72788299104c1c33b8948c6f3bfc3f404f2be9a7 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 18:32:41 +0100
Subject: [PATCH 08/31] Move files within maplibre-winit directory

---
 android/src/lib.rs                      |   2 +-
 apple/src/lib.rs                        |   2 +-
 maplibre-demo/src/headless.rs           |   2 +-
 maplibre-demo/src/main.rs               |   2 +-
 maplibre-winit/src/lib.rs               | 223 +++++++++++++++++++++++-
 maplibre-winit/src/{winit => }/noweb.rs |   0
 maplibre-winit/src/{winit => }/web.rs   |   0
 maplibre-winit/src/winit/mod.rs         | 221 -----------------------
 web/src/lib.rs                          |   2 +-
 9 files changed, 227 insertions(+), 227 deletions(-)
 rename maplibre-winit/src/{winit => }/noweb.rs (100%)
 rename maplibre-winit/src/{winit => }/web.rs (100%)
 delete mode 100644 maplibre-winit/src/winit/mod.rs

diff --git a/android/src/lib.rs b/android/src/lib.rs
index 968298bb..5217253b 100644
--- a/android/src/lib.rs
+++ b/android/src/lib.rs
@@ -7,7 +7,7 @@ use maplibre::{
     render::settings::{Backends, WgpuSettings},
     MapBuilder,
 };
-use maplibre_winit::winit::{run_headed_map, WinitMapWindowConfig};
+use maplibre_winit::{run_headed_map, WinitMapWindowConfig};
 
 #[cfg(not(target_os = "android"))]
 compile_error!("android works only on android.");
diff --git a/apple/src/lib.rs b/apple/src/lib.rs
index b3080c4b..a3820041 100644
--- a/apple/src/lib.rs
+++ b/apple/src/lib.rs
@@ -3,7 +3,7 @@ use maplibre::{
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
     MapBuilder,
 };
-use maplibre_winit::winit::{
+use maplibre_winit::{
     run_headed_map, WinitEnvironment, WinitEventLoop, WinitMapWindow, WinitMapWindowConfig,
     WinitWindow,
 };
diff --git a/maplibre-demo/src/headless.rs b/maplibre-demo/src/headless.rs
index abee2cc2..633fc2ec 100644
--- a/maplibre-demo/src/headless.rs
+++ b/maplibre-demo/src/headless.rs
@@ -13,7 +13,7 @@ use maplibre::{
     util::grid::google_mercator,
     window::WindowSize,
 };
-use maplibre_winit::winit::WinitEnvironment;
+use maplibre_winit::WinitEnvironment;
 use tile_grid::{extent_wgs84_to_merc, Extent, GridIterator};
 
 pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
diff --git a/maplibre-demo/src/main.rs b/maplibre-demo/src/main.rs
index abea8cce..ff38891d 100644
--- a/maplibre-demo/src/main.rs
+++ b/maplibre-demo/src/main.rs
@@ -2,7 +2,7 @@ use std::io::ErrorKind;
 
 use clap::{builder::ValueParser, Parser, Subcommand};
 use maplibre::{coords::LatLon, platform::run_multithreaded};
-use maplibre_winit::winit::run_headed_map;
+use maplibre_winit::run_headed_map;
 
 use crate::headless::run_headless;
 
diff --git a/maplibre-winit/src/lib.rs b/maplibre-winit/src/lib.rs
index 0e7d9675..f02f0dec 100644
--- a/maplibre-winit/src/lib.rs
+++ b/maplibre-winit/src/lib.rs
@@ -1,2 +1,223 @@
 pub mod input;
-pub mod winit;
+
+use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
+
+use instant::Instant;
+use maplibre::{
+    environment::Environment,
+    error::Error,
+    event_loop::{EventLoop, EventLoopProxy},
+    io::{
+        apc::{AsyncProcedureCall, Message},
+        scheduler::Scheduler,
+        source_client::HttpClient,
+        transferables::{DefaultTransferables, Transferables},
+    },
+    map::Map,
+    window::{HeadedMapWindow, MapWindowConfig},
+};
+use winit::{
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::ControlFlow,
+};
+
+use crate::input::{InputController, UpdateState};
+
+pub type RawWinitWindow = winit::window::Window;
+pub type RawWinitEventLoop<ET> = winit::event_loop::EventLoop<ET>;
+pub type RawEventLoopProxy<ET> = winit::event_loop::EventLoopProxy<ET>;
+
+#[cfg(target_arch = "wasm32")]
+mod web;
+
+#[cfg(not(target_arch = "wasm32"))]
+mod noweb;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use noweb::*;
+#[cfg(target_arch = "wasm32")]
+pub use web::*;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct WinitMapWindowConfig<ET> {
+    title: String,
+
+    phantom_et: PhantomData<ET>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl<ET> WinitMapWindowConfig<ET> {
+    pub fn new(title: String) -> Self {
+        Self {
+            title,
+            phantom_et: Default::default(),
+        }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+pub struct WinitMapWindowConfig {
+    canvas_id: String,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl WinitMapWindowConfig {
+    pub fn new(canvas_id: String) -> Self {
+        Self { canvas_id }
+    }
+}
+
+pub struct WinitMapWindow<ET: 'static> {
+    window: RawWinitWindow,
+    event_loop: Option<WinitEventLoop<ET>>,
+}
+
+impl<ET> WinitMapWindow<ET> {
+    pub fn take_event_loop(&mut self) -> Option<WinitEventLoop<ET>> {
+        self.event_loop.take()
+    }
+}
+
+pub struct WinitEventLoop<ET: 'static> {
+    event_loop: RawWinitEventLoop<ET>,
+}
+
+impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
+    type EventLoopProxy = WinitEventLoopProxy<ET>;
+
+    fn run<E>(
+        mut self,
+        mut window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
+        mut map: Map<E>,
+        max_frames: Option<u64>,
+    ) where
+        E: Environment,
+        <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
+    {
+        let mut last_render_time = Instant::now();
+        let mut current_frame: u64 = 0;
+
+        let mut input_controller = InputController::new(0.2, 100.0, 0.1);
+
+        self.event_loop
+            .run(move |event, window_target, control_flow| {
+                #[cfg(target_os = "android")]
+                if !map.is_initialized() && event == Event::Resumed {
+                    use tokio::{runtime::Handle, task};
+
+                    task::block_in_place(|| {
+                        Handle::current().block_on(async {
+                            map.late_init().await;
+                        })
+                    });
+                    return;
+                }
+
+                match event {
+                    Event::DeviceEvent {
+                        ref event,
+                        .. // We're not using device_id currently
+                    } => {
+                        input_controller.device_input(event);
+                    }
+
+                    Event::WindowEvent {
+                        ref event,
+                        window_id,
+                    } if window_id == window.id().into() => {
+                        if !input_controller.window_input(event) {
+                            match event {
+                                WindowEvent::CloseRequested
+                                | WindowEvent::KeyboardInput {
+                                    input:
+                                    KeyboardInput {
+                                        state: ElementState::Pressed,
+                                        virtual_keycode: Some(VirtualKeyCode::Escape),
+                                        ..
+                                    },
+                                    ..
+                                } => *control_flow = ControlFlow::Exit,
+                                WindowEvent::Resized(physical_size) => {
+                                    // FIXME map.resize(physical_size.width, physical_size.height);
+                                }
+                                WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
+                                    // FIXME map.resize(new_inner_size.width, new_inner_size.height);
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                    Event::RedrawRequested(_) => {
+                        let now = Instant::now();
+                        let dt = now - last_render_time;
+                        last_render_time = now;
+
+                        // FIXME input_controller.update_state(map.view_state_mut(), dt);
+
+                        match map.run_schedule() {
+                            Ok(_) => {}
+                            Err(Error::Render(e)) => {
+                                eprintln!("{}", e);
+                                if e.should_exit() {
+                                    *control_flow = ControlFlow::Exit;
+                                }
+                            }
+                            e => eprintln!("{:?}", e)
+                        };
+
+                        if let Some(max_frames) = max_frames {
+                            if current_frame >= max_frames {
+                                log::info!("Exiting because maximum frames reached.");
+                                *control_flow = ControlFlow::Exit;
+                            }
+
+                            current_frame += 1;
+                        }
+                    }
+                    Event::Suspended => {
+                        // FIXME unimplemented!()
+                    }
+                    Event::Resumed => {
+                        // FIXME unimplemented!()
+                    }
+                    Event::MainEventsCleared => {
+                        // RedrawRequested will only trigger once, unless we manually
+                        // request it.
+                        window.request_redraw();
+                    }
+                    _ => {}
+                }
+            });
+    }
+
+    fn create_proxy(&self) -> Self::EventLoopProxy {
+        WinitEventLoopProxy {
+            proxy: self.event_loop.create_proxy(),
+        }
+    }
+}
+pub struct WinitEventLoopProxy<ET: 'static> {
+    proxy: RawEventLoopProxy<ET>,
+}
+
+impl<ET: 'static> EventLoopProxy<ET> for WinitEventLoopProxy<ET> {
+    fn send_event(&self, event: ET) {
+        self.proxy.send_event(event); // FIXME: Handle unwrap
+    }
+}
+
+pub struct WinitEnvironment<S: Scheduler, HC: HttpClient, APC: AsyncProcedureCall<HC>, ET> {
+    phantom_s: PhantomData<S>,
+    phantom_hc: PhantomData<HC>,
+    phantom_apc: PhantomData<APC>,
+    phantom_et: PhantomData<ET>,
+}
+
+impl<S: Scheduler, HC: HttpClient, APC: AsyncProcedureCall<HC>, ET: 'static> Environment
+    for WinitEnvironment<S, HC, APC, ET>
+{
+    type MapWindowConfig = WinitMapWindowConfig<ET>;
+    type AsyncProcedureCall = APC;
+    type Scheduler = S;
+    type HttpClient = HC;
+}
diff --git a/maplibre-winit/src/winit/noweb.rs b/maplibre-winit/src/noweb.rs
similarity index 100%
rename from maplibre-winit/src/winit/noweb.rs
rename to maplibre-winit/src/noweb.rs
diff --git a/maplibre-winit/src/winit/web.rs b/maplibre-winit/src/web.rs
similarity index 100%
rename from maplibre-winit/src/winit/web.rs
rename to maplibre-winit/src/web.rs
diff --git a/maplibre-winit/src/winit/mod.rs b/maplibre-winit/src/winit/mod.rs
deleted file mode 100644
index c705b87a..00000000
--- a/maplibre-winit/src/winit/mod.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
-
-use instant::Instant;
-use maplibre::{
-    environment::Environment,
-    error::Error,
-    event_loop::{EventLoop, EventLoopProxy},
-    io::{
-        apc::{AsyncProcedureCall, Message},
-        scheduler::Scheduler,
-        source_client::HttpClient,
-        transferables::{DefaultTransferables, Transferables},
-    },
-    map::Map,
-    window::{HeadedMapWindow, MapWindowConfig},
-};
-use winit::{
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-    event_loop::ControlFlow,
-};
-
-use crate::input::{InputController, UpdateState};
-
-pub type RawWinitWindow = winit::window::Window;
-pub type RawWinitEventLoop<ET> = winit::event_loop::EventLoop<ET>;
-pub type RawEventLoopProxy<ET> = winit::event_loop::EventLoopProxy<ET>;
-
-#[cfg(target_arch = "wasm32")]
-mod web;
-
-#[cfg(not(target_arch = "wasm32"))]
-mod noweb;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use noweb::*;
-#[cfg(target_arch = "wasm32")]
-pub use web::*;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub struct WinitMapWindowConfig<ET> {
-    title: String,
-
-    phantom_et: PhantomData<ET>,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl<ET> WinitMapWindowConfig<ET> {
-    pub fn new(title: String) -> Self {
-        Self {
-            title,
-            phantom_et: Default::default(),
-        }
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-pub struct WinitMapWindowConfig {
-    canvas_id: String,
-}
-
-#[cfg(target_arch = "wasm32")]
-impl WinitMapWindowConfig {
-    pub fn new(canvas_id: String) -> Self {
-        Self { canvas_id }
-    }
-}
-
-pub struct WinitMapWindow<ET: 'static> {
-    window: RawWinitWindow,
-    event_loop: Option<WinitEventLoop<ET>>,
-}
-
-impl<ET> WinitMapWindow<ET> {
-    pub fn take_event_loop(&mut self) -> Option<WinitEventLoop<ET>> {
-        self.event_loop.take()
-    }
-}
-
-pub struct WinitEventLoop<ET: 'static> {
-    event_loop: RawWinitEventLoop<ET>,
-}
-
-impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
-    type EventLoopProxy = WinitEventLoopProxy<ET>;
-
-    fn run<E>(
-        mut self,
-        mut window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
-        mut map: Map<E>,
-        max_frames: Option<u64>,
-    ) where
-        E: Environment,
-        <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
-    {
-        let mut last_render_time = Instant::now();
-        let mut current_frame: u64 = 0;
-
-        let mut input_controller = InputController::new(0.2, 100.0, 0.1);
-
-        self.event_loop
-            .run(move |event, window_target, control_flow| {
-                #[cfg(target_os = "android")]
-                if !map.is_initialized() && event == Event::Resumed {
-                    use tokio::{runtime::Handle, task};
-
-                    task::block_in_place(|| {
-                        Handle::current().block_on(async {
-                            map.late_init().await;
-                        })
-                    });
-                    return;
-                }
-
-                match event {
-                    Event::DeviceEvent {
-                        ref event,
-                        .. // We're not using device_id currently
-                    } => {
-                        input_controller.device_input(event);
-                    }
-
-                    Event::WindowEvent {
-                        ref event,
-                        window_id,
-                    } if window_id == window.id().into() => {
-                        if !input_controller.window_input(event) {
-                            match event {
-                                WindowEvent::CloseRequested
-                                | WindowEvent::KeyboardInput {
-                                    input:
-                                    KeyboardInput {
-                                        state: ElementState::Pressed,
-                                        virtual_keycode: Some(VirtualKeyCode::Escape),
-                                        ..
-                                    },
-                                    ..
-                                } => *control_flow = ControlFlow::Exit,
-                                WindowEvent::Resized(physical_size) => {
-                                    // FIXME map.resize(physical_size.width, physical_size.height);
-                                }
-                                WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                                    // FIXME map.resize(new_inner_size.width, new_inner_size.height);
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
-                    Event::RedrawRequested(_) => {
-                        let now = Instant::now();
-                        let dt = now - last_render_time;
-                        last_render_time = now;
-
-                        // FIXME input_controller.update_state(map.view_state_mut(), dt);
-
-                        match map.run_schedule() {
-                            Ok(_) => {}
-                            Err(Error::Render(e)) => {
-                                eprintln!("{}", e);
-                                if e.should_exit() {
-                                    *control_flow = ControlFlow::Exit;
-                                }
-                            }
-                            e => eprintln!("{:?}", e)
-                        };
-
-                        if let Some(max_frames) = max_frames {
-                            if current_frame >= max_frames {
-                                log::info!("Exiting because maximum frames reached.");
-                                *control_flow = ControlFlow::Exit;
-                            }
-
-                            current_frame += 1;
-                        }
-                    }
-                    Event::Suspended => {
-                        // FIXME unimplemented!()
-                    }
-                    Event::Resumed => {
-                        // FIXME unimplemented!()
-                    }
-                    Event::MainEventsCleared => {
-                        // RedrawRequested will only trigger once, unless we manually
-                        // request it.
-                        window.request_redraw();
-                    }
-                    _ => {}
-                }
-            });
-    }
-
-    fn create_proxy(&self) -> Self::EventLoopProxy {
-        WinitEventLoopProxy {
-            proxy: self.event_loop.create_proxy(),
-        }
-    }
-}
-pub struct WinitEventLoopProxy<ET: 'static> {
-    proxy: RawEventLoopProxy<ET>,
-}
-
-impl<ET: 'static> EventLoopProxy<ET> for WinitEventLoopProxy<ET> {
-    fn send_event(&self, event: ET) {
-        self.proxy.send_event(event); // FIXME: Handle unwrap
-    }
-}
-
-pub struct WinitEnvironment<S: Scheduler, HC: HttpClient, APC: AsyncProcedureCall<HC>, ET> {
-    phantom_s: PhantomData<S>,
-    phantom_hc: PhantomData<HC>,
-    phantom_apc: PhantomData<APC>,
-    phantom_et: PhantomData<ET>,
-}
-
-impl<S: Scheduler, HC: HttpClient, APC: AsyncProcedureCall<HC>, ET: 'static> Environment
-    for WinitEnvironment<S, HC, APC, ET>
-{
-    type MapWindowConfig = WinitMapWindowConfig<ET>;
-    type AsyncProcedureCall = APC;
-    type Scheduler = S;
-    type HttpClient = HC;
-}
diff --git a/web/src/lib.rs b/web/src/lib.rs
index cfb7f972..2e54d83e 100644
--- a/web/src/lib.rs
+++ b/web/src/lib.rs
@@ -3,7 +3,7 @@
 use std::{borrow::BorrowMut, cell::RefCell, mem, ops::Deref, panic, rc::Rc};
 
 use maplibre::{io::scheduler::NopScheduler, Map, MapBuilder};
-use maplibre_winit::winit::{WinitEnvironment, WinitMapWindowConfig};
+use maplibre_winit::{WinitEnvironment, WinitMapWindowConfig};
 use wasm_bindgen::prelude::*;
 
 use crate::platform::http_client::WHATWGFetchHttpClient;

From 6fab04c70ffb104e1562c4910cfce309815ad9fb Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 18:38:49 +0100
Subject: [PATCH 09/31] Fix moving the map and resizing

---
 maplibre-winit/src/lib.rs   | 6 +++---
 maplibre-winit/src/noweb.rs | 2 +-
 maplibre/src/context.rs     | 6 +++++-
 maplibre/src/map.rs         | 8 ++++++++
 maplibre/src/world.rs       | 9 +++++++++
 5 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/maplibre-winit/src/lib.rs b/maplibre-winit/src/lib.rs
index f02f0dec..b3a6c15b 100644
--- a/maplibre-winit/src/lib.rs
+++ b/maplibre-winit/src/lib.rs
@@ -138,10 +138,10 @@ impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
                                     ..
                                 } => *control_flow = ControlFlow::Exit,
                                 WindowEvent::Resized(physical_size) => {
-                                    // FIXME map.resize(physical_size.width, physical_size.height);
+                                    map.context_mut().resize(physical_size.width, physical_size.height);
                                 }
                                 WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                                    // FIXME map.resize(new_inner_size.width, new_inner_size.height);
+                                    map.context_mut().resize(new_inner_size.width, new_inner_size.height);
                                 }
                                 _ => {}
                             }
@@ -152,7 +152,7 @@ impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
                         let dt = now - last_render_time;
                         last_render_time = now;
 
-                        // FIXME input_controller.update_state(map.view_state_mut(), dt);
+                        input_controller.update_state(map.context_mut().world.view_state_mut(), dt);
 
                         match map.run_schedule() {
                             Ok(_) => {}
diff --git a/maplibre-winit/src/noweb.rs b/maplibre-winit/src/noweb.rs
index a2c586f9..0849b968 100644
--- a/maplibre-winit/src/noweb.rs
+++ b/maplibre-winit/src/noweb.rs
@@ -17,7 +17,7 @@ use maplibre::{
 use winit::window::WindowBuilder;
 
 use super::{RawWinitEventLoop, RawWinitWindow, WinitMapWindow, WinitMapWindowConfig};
-use crate::winit::{WinitEnvironment, WinitEventLoop};
+use crate::{WinitEnvironment, WinitEventLoop};
 
 impl<T> MapWindow for WinitMapWindow<T> {
     fn size(&self) -> WindowSize {
diff --git a/maplibre/src/context.rs b/maplibre/src/context.rs
index 20f06401..e8466d95 100644
--- a/maplibre/src/context.rs
+++ b/maplibre/src/context.rs
@@ -1,4 +1,8 @@
-use crate::{render::Renderer, style::Style, world::World};
+use crate::{
+    render::Renderer,
+    style::Style,
+    world::{ViewState, World},
+};
 
 /// Stores the context of the map.
 pub struct MapContext {
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index d6bef2b9..1f6ba7f3 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -57,4 +57,12 @@ impl<E: Environment> Map<E> {
         self.schedule.run(&mut self.map_context);
         Ok(())
     }
+
+    pub fn context(&self) -> &MapContext {
+        &self.map_context
+    }
+
+    pub fn context_mut(&mut self) -> &mut MapContext {
+        &mut self.map_context
+    }
 }
diff --git a/maplibre/src/world.rs b/maplibre/src/world.rs
index 42f5cb78..f88dd86f 100644
--- a/maplibre/src/world.rs
+++ b/maplibre/src/world.rs
@@ -3,6 +3,7 @@ use std::ops::{Deref, DerefMut};
 use cgmath::{Angle, Point3};
 
 use crate::{
+    context::MapContext,
     coords::{LatLon, ViewRegion, WorldCoords, Zoom, ZoomLevel, TILE_SIZE},
     io::tile_repository::TileRepository,
     render::camera::{Camera, Perspective, ViewProjection},
@@ -52,6 +53,14 @@ impl World {
             tile_repository,
         }
     }
+
+    pub fn view_state(&self) -> &ViewState {
+        &self.view_state
+    }
+
+    pub fn view_state_mut(&mut self) -> &mut ViewState {
+        &mut self.view_state
+    }
 }
 
 /// Stores the camera configuration.

From 1ea049f99554d7368ccee77c7925da5f666d0f30 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 19:54:40 +0100
Subject: [PATCH 10/31] Propagate errors

---
 web/lib/build.mjs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/web/lib/build.mjs b/web/lib/build.mjs
index b166a193..b370c288 100644
--- a/web/lib/build.mjs
+++ b/web/lib/build.mjs
@@ -121,7 +121,7 @@ const emitTypeScript = () => {
     });
 
     if (child.status !== 0) {
-        console.error("Failed to execute tsc")
+        throw new Error("Failed to execute tsc")
     }
 }
 
@@ -154,7 +154,7 @@ const wasmPack = () => {
     });
 
     if (cargo.status !== 0) {
-        console.error("Failed to execute cargo build")
+        throw new Error("Failed to execute cargo build")
     }
 
     let wasmbindgen = spawnSync('wasm-bindgen', [
@@ -170,7 +170,7 @@ const wasmPack = () => {
     });
 
     if (wasmbindgen.status !== 0) {
-        console.error("Failed to execute wasm-bindgen")
+        throw new Error("Failed to execute wasm-bindgen")
     }
 
     if (release) {
@@ -186,10 +186,9 @@ const wasmPack = () => {
         });
 
         if (wasmOpt.status !== 0) {
-            console.error("Failed to execute wasm-opt")
+            throw new Error("Failed to execute wasm-opt")
         }
     }
-
 }
 
 const watchResult = async (result) => {
@@ -260,4 +259,8 @@ const start = async () => {
     emitTypeScript();
 }
 
-const _ = start()
+try {
+    const _ = start()
+} catch (e) {
+    console.log("Failed to start building: " + e.message)
+}

From e0f414e804d8d4e4c0192e1f8cc766ec1527d882 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 19:54:47 +0100
Subject: [PATCH 11/31] Fix imports

---
 maplibre/src/map.rs                | 1 -
 maplibre/src/render/graph/graph.rs | 4 ++--
 maplibre/src/render/mod.rs         | 6 ++----
 3 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index 1f6ba7f3..d8b119b6 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -5,7 +5,6 @@ use crate::{
     coords::{LatLon, WorldCoords, Zoom, TILE_SIZE},
     environment::Environment,
     error::Error,
-    headless::environment::HeadlessEnvironment,
     kernel::Kernel,
     render::{create_default_render_graph, register_default_render_stages, Renderer},
     schedule::{Schedule, Stage},
diff --git a/maplibre/src/render/graph/graph.rs b/maplibre/src/render/graph/graph.rs
index 2dfc7441..981c8258 100644
--- a/maplibre/src/render/graph/graph.rs
+++ b/maplibre/src/render/graph/graph.rs
@@ -574,8 +574,8 @@ mod tests {
         Edge, Node, NodeId, NodeRunError, RenderGraph, RenderGraphContext, RenderGraphError,
         SlotInfo,
     };
-    use crate::{
-        render::graph::{RenderContext, SlotType},
+    use crate::render::{
+        graph::{RenderContext, SlotType},
         RenderState,
     };
 
diff --git a/maplibre/src/render/mod.rs b/maplibre/src/render/mod.rs
index d7224b6c..d811b419 100644
--- a/maplibre/src/render/mod.rs
+++ b/maplibre/src/render/mod.rs
@@ -415,7 +415,6 @@ mod tests {
     use crate::{
         render::{settings::RendererSettings, RenderState},
         window::{MapWindow, MapWindowConfig, WindowSize},
-        MapWindow, MapWindowConfig, WindowSize,
     };
 
     pub struct HeadlessMapWindowConfig {
@@ -445,9 +444,8 @@ mod tests {
     async fn test_render() {
         use log::LevelFilter;
 
-        use crate::{
-            render::{graph::RenderGraph, graph_runner::RenderGraphRunner, resource::Surface},
-            RenderState, RendererSettings,
+        use crate::render::{
+            graph::RenderGraph, graph_runner::RenderGraphRunner, resource::Surface,
         };
 
         let _ = env_logger::builder()

From 58c852f096d472af75d066519bcf2f225dbf6f97 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 19:57:42 +0100
Subject: [PATCH 12/31] Fix imports

---
 maplibre/src/render/tile_pipeline.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/maplibre/src/render/tile_pipeline.rs b/maplibre/src/render/tile_pipeline.rs
index 1e0afedd..90f5d9b1 100644
--- a/maplibre/src/render/tile_pipeline.rs
+++ b/maplibre/src/render/tile_pipeline.rs
@@ -6,10 +6,9 @@ use crate::{
     platform::MIN_WEBGL_BUFFER_SIZE,
     render::{
         resource::{FragmentState, RenderPipeline, RenderPipelineDescriptor, VertexState},
-        settings::Msaa,
+        settings::{Msaa, RendererSettings},
         shaders::ShaderGlobals,
     },
-    RendererSettings,
 };
 
 pub struct TilePipeline {

From 92301d005ef9278c42e549853b42f10c769ef964 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 20:42:08 +0100
Subject: [PATCH 13/31] Add documentation

---
 maplibre/src/environment.rs                   |  8 +++
 maplibre/src/headless/map.rs                  |  2 +-
 maplibre/src/io/apc.rs                        | 63 +++++++++++++++++--
 maplibre/src/kernel.rs                        | 35 +++++++++--
 maplibre/src/render/builder.rs                |  4 +-
 .../src/stages/populate_tile_store_stage.rs   |  2 +-
 maplibre/src/stages/request_stage.rs          |  5 +-
 web/src/platform/singlethreaded/apc.rs        |  2 +-
 8 files changed, 105 insertions(+), 16 deletions(-)

diff --git a/maplibre/src/environment.rs b/maplibre/src/environment.rs
index 6c496265..1bcd1379 100644
--- a/maplibre/src/environment.rs
+++ b/maplibre/src/environment.rs
@@ -12,6 +12,14 @@ use crate::{
     window::MapWindowConfig,
 };
 
+/// The environment defines which types must be injected into maplibre at compile time.
+/// Essentially, this trait implements the
+/// [dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) design pattern.
+/// By instantiating this trait at compile time with concrete types, it is possible to create
+/// different compile-time instances of maplibre.
+///
+/// For example it is possible to change the way tasks are scheduled. It is also possible to change
+/// the HTTP implementation for fetching tiles over the network.
 pub trait Environment: 'static {
     type MapWindowConfig: MapWindowConfig;
 
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index efee9b3c..00433bd4 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -97,7 +97,7 @@ impl HeadlessMap {
         coords: WorldTileCoords,
         source_layers: &[&str],
     ) -> Result<StoredTile, Error> {
-        let source_client = &self.kernel.source_client;
+        let source_client = self.kernel.source_client();
 
         let data = source_client.fetch(&coords).await?.into_boxed_slice();
 
diff --git a/maplibre/src/io/apc.rs b/maplibre/src/io/apc.rs
index 9761b2ba..d461717f 100644
--- a/maplibre/src/io/apc.rs
+++ b/maplibre/src/io/apc.rs
@@ -20,9 +20,12 @@ use crate::{
     },
 };
 
-/// The result of the tessellation of a tile.
-/// `TessellatedLayer` contains the result of the tessellation for a specific layer, otherwise
-/// `UnavailableLayer` if the layer doesn't exist.
+/// The result of the tessellation of a tile. This is sent as a message from a worker to the caller
+/// of an [`AsyncProcedure`].
+///
+/// * `TessellatedLayer` contains the result of the tessellation for a specific layer.
+/// * `UnavailableLayer` is sent if a requested layer is not found.
+/// * `TileTessellated` is sent if processing of a tile finished.
 #[derive(Clone)]
 pub enum Message<T: Transferables> {
     TileTessellated(T::TileTessellated),
@@ -30,12 +33,15 @@ pub enum Message<T: Transferables> {
     TessellatedLayer(T::TessellatedLayer),
 }
 
+/// Inputs for an [`AsyncProcedure`]
 #[derive(Clone, Serialize, Deserialize)]
 pub enum Input {
     TileRequest(TileRequest),
 }
 
+/// Allows sending messages from workers to back to the caller.
 pub trait Context<T: Transferables, HC: HttpClient>: Send + 'static {
+    /// Send a message back to the caller.
     fn send(&self, data: Message<T>);
 
     fn source_client(&self) -> &SourceClient<HC>;
@@ -46,15 +52,62 @@ pub type AsyncProcedureFuture = Pin<Box<(dyn Future<Output = ()> + Send + 'stati
 #[cfg(not(feature = "thread-safe-futures"))]
 pub type AsyncProcedureFuture = Pin<Box<(dyn Future<Output = ()> + 'static)>>;
 
+/// Type definitions for asynchronous procedure calls. These functions can be called in an
+/// [`AsyncProcedureCall`]. Functions of this type are required to be statically available at
+/// compile time. It is explicitly not possible to use closures, as they would require special
+/// serialization which is currently not supported.
 pub type AsyncProcedure<C> = fn(input: Input, context: C) -> AsyncProcedureFuture;
 
+/// APCs define an interface for performing work asynchronously.
+/// This work can be implemented through procedures which can be called asynchronously, hence the
+/// name AsyncProcedureCall or APC for short.
+///
+/// APCs serve as an abstraction for doing work on a separate thread, and then getting responses
+/// back. An asynchronous procedure call can for example be performed by using message passing. In
+/// fact this could theoretically work over a network socket.
+///
+/// It is possible to schedule work on a  remote host by calling [`AsyncProcedureCall::call()`]
+/// and getting the results back by calling the non-blocking function
+/// [`AsyncProcedureCall::receive()`]. The [`AsyncProcedureCall::receive()`] function returns a
+/// struct which implements [`Transferables`].
+///
+/// ## Transferables
+///
+/// Based on whether the current platform supports shared-memory or not, the implementation of APCs
+/// might want to send the whole data from the worker to the caller back or just pointers to that
+/// data. The [`Transferables`] trait allows developers to define that and use different data
+/// layouts for different platforms.
+///
+/// ## Message Passing vs APC
+///
+/// One might wonder why this is called [`AsyncProcedureCall`] instead of `MessagePassingInterface`.
+/// The reason for this is quite simple. We are actually referencing and calling procedures which
+/// are defined in different threads, processes or hosts. That means, that an [`AsyncProcedureCall`]
+/// is actually distinct from a `MessagePassingInterface`.
+///
+///
+/// ## Current Implementations
+///
+/// We currently have two implementation for APCs. One uses the Tokio async runtime on native
+/// targets in [`SchedulerAsyncProcedureCall`].
+/// For the web we implemented an alternative way to call APCs which is called
+/// [`PassingAsyncProcedureCall`]. This implementation does not depend on shared-memory compared to
+/// [`SchedulerAsyncProcedureCall`]. In fact, on the web we are currently not depending on
+/// shared-memory because that feature is hidden behind feature flags in browsers
+/// (see [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer).
+///
+///
+// TODO: Rename to AsyncProcedureCaller?
 pub trait AsyncProcedureCall<HC: HttpClient>: 'static {
     type Context: Context<Self::Transferables, HC> + Send;
     type Transferables: Transferables;
 
+    /// Try to receive a message non-blocking.
     fn receive(&self) -> Option<Message<Self::Transferables>>;
 
-    fn schedule(&self, input: Input, procedure: AsyncProcedure<Self::Context>);
+    /// Call an [`AsyncProcedure`] using some [`Input`]. This function is non-blocking and
+    /// returns immediately.
+    fn call(&self, input: Input, procedure: AsyncProcedure<Self::Context>);
 }
 
 #[derive(Clone)]
@@ -101,7 +154,7 @@ impl<HC: HttpClient, S: Scheduler> AsyncProcedureCall<HC> for SchedulerAsyncProc
         Some(transferred)
     }
 
-    fn schedule(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
+    fn call(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
         let sender = self.channel.0.clone();
         let client = self.http_client.clone(); // FIXME (wasm-executor): do not clone each time
 
diff --git a/maplibre/src/kernel.rs b/maplibre/src/kernel.rs
index c16ac33d..a2cdf385 100644
--- a/maplibre/src/kernel.rs
+++ b/maplibre/src/kernel.rs
@@ -3,13 +3,40 @@ use crate::{
     io::source_client::{HttpSourceClient, SourceClient},
 };
 
+/// Holds references to core constructs of maplibre. Based on the compile-time initialization
+/// different implementations for handling windows, asynchronous work, or data sources are provided
+/// through a [`Kernel`].
+///
+/// An [`Environment`] defines the types which are used.
+///
+/// A Kernel lives as long as a [Map](crate::map::Map) usually. It is shared through out various
+/// components of the maplibre library.
 pub struct Kernel<E: Environment> {
-    pub map_window_config: E::MapWindowConfig,
-    pub apc: E::AsyncProcedureCall,
-    pub scheduler: E::Scheduler,
-    pub source_client: SourceClient<E::HttpClient>,
+    map_window_config: E::MapWindowConfig,
+    apc: E::AsyncProcedureCall,
+    scheduler: E::Scheduler,
+    source_client: SourceClient<E::HttpClient>,
 }
 
+impl<E: Environment> Kernel<E> {
+    pub fn map_window_config(&self) -> &E::MapWindowConfig {
+        &self.map_window_config
+    }
+
+    pub fn apc(&self) -> &E::AsyncProcedureCall {
+        &self.apc
+    }
+
+    pub fn scheduler(&self) -> &E::Scheduler {
+        &self.scheduler
+    }
+
+    pub fn source_client(&self) -> &SourceClient<E::HttpClient> {
+        &self.source_client
+    }
+}
+
+/// A convenient builder for [Kernels](Kernel).
 pub struct KernelBuilder<E: Environment> {
     map_window_config: Option<E::MapWindowConfig>,
     apc: Option<E::AsyncProcedureCall>,
diff --git a/maplibre/src/render/builder.rs b/maplibre/src/render/builder.rs
index f2828f77..b6383e3f 100644
--- a/maplibre/src/render/builder.rs
+++ b/maplibre/src/render/builder.rs
@@ -102,7 +102,7 @@ where
     where
         E: Environment<MapWindowConfig = MWC>,
     {
-        self.initialize(&kernel.map_window_config).await
+        self.initialize(kernel.map_window_config()).await
     }
 }
 
@@ -123,7 +123,7 @@ impl<MWC: MapWindowConfig> UninitializedRenderer<MWC> {
     where
         E: Environment<MapWindowConfig = MWC>,
     {
-        self.initialize_headless(&kernel.map_window_config).await
+        self.initialize_headless(kernel.map_window_config()).await
     }
 }
 
diff --git a/maplibre/src/stages/populate_tile_store_stage.rs b/maplibre/src/stages/populate_tile_store_stage.rs
index c5c4b2c4..3fceaf47 100644
--- a/maplibre/src/stages/populate_tile_store_stage.rs
+++ b/maplibre/src/stages/populate_tile_store_stage.rs
@@ -35,7 +35,7 @@ impl<E: Environment> Stage for PopulateTileStore<E> {
             ..
         }: &mut MapContext,
     ) {
-        if let Some(result) = self.kernel.apc.receive() {
+        if let Some(result) = self.kernel.apc().receive() {
             match result {
                 Message::TileTessellated(tranferred) => {
                     let coords = tranferred.coords();
diff --git a/maplibre/src/stages/request_stage.rs b/maplibre/src/stages/request_stage.rs
index 3c8ce95f..afe0e13c 100644
--- a/maplibre/src/stages/request_stage.rs
+++ b/maplibre/src/stages/request_stage.rs
@@ -150,7 +150,8 @@ impl<E: Environment> RequestStage<E> {
         coords: WorldTileCoords,
         layers: &HashSet<String>,
     ) -> Result<(), Error> {
-        /*        if !tile_repository.is_layers_missing(coords, layers) {
+        /* TODO: is this still required?
+        if !tile_repository.is_layers_missing(coords, layers) {
             return Ok(false);
         }*/
 
@@ -158,7 +159,7 @@ impl<E: Environment> RequestStage<E> {
             tile_repository.create_tile(coords);
 
             tracing::info!("new tile request: {}", &coords);
-            self.kernel.apc.schedule(
+            self.kernel.apc().call(
                 Input::TileRequest(TileRequest {
                     coords,
                     layers: layers.clone(),
diff --git a/web/src/platform/singlethreaded/apc.rs b/web/src/platform/singlethreaded/apc.rs
index 0131feb1..1b7f5ee4 100644
--- a/web/src/platform/singlethreaded/apc.rs
+++ b/web/src/platform/singlethreaded/apc.rs
@@ -185,7 +185,7 @@ impl AsyncProcedureCall<UsedTransferables, UsedHttpClient> for PassingAsyncProce
         self.received.pop()
     }
 
-    fn schedule(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
+    fn call(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
         let procedure_ptr = procedure as *mut AsyncProcedure<Self::Context> as u32; // FIXME (wasm-executor): is u32 fine, define an overflow safe function?
         let input = serde_json::to_string(&input).unwrap(); // FIXME (wasm-executor): Remove unwrap
 

From 6b1fa188c2263ca7e459cfe1b56ca58c4f930ae7 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 20:59:17 +0100
Subject: [PATCH 14/31] Address some FIXMEs

---
 maplibre/src/error.rs                         |  1 +
 maplibre/src/io/apc.rs                        | 10 ++++---
 maplibre/src/io/pipeline.rs                   | 20 +++++++++++---
 maplibre/src/io/tile_pipelines.rs             |  5 ++++
 maplibre/src/io/transferables.rs              |  2 +-
 maplibre/src/stages/mod.rs                    | 10 ++++---
 maplibre/src/stages/request_stage.rs          |  1 +
 maplibre/src/tessellation/mod.rs              |  1 -
 .../platform/multithreaded/pool_scheduler.rs  | 26 +++++++++----------
 web/src/platform/singlethreaded/apc.rs        |  9 ++++---
 .../platform/singlethreaded/transferables.rs  |  7 +++--
 11 files changed, 59 insertions(+), 33 deletions(-)

diff --git a/maplibre/src/error.rs b/maplibre/src/error.rs
index cd2d1fe3..7b6bedf1 100644
--- a/maplibre/src/error.rs
+++ b/maplibre/src/error.rs
@@ -9,6 +9,7 @@ use crate::render::{error::RenderError, graph::RenderGraphError};
 /// Enumeration of errors which can happen during the operation of the library.
 #[derive(Debug)]
 pub enum Error {
+    APC,
     Scheduler,
     Network(String),
     Tesselation(TessellationError),
diff --git a/maplibre/src/io/apc.rs b/maplibre/src/io/apc.rs
index d461717f..7ce1423f 100644
--- a/maplibre/src/io/apc.rs
+++ b/maplibre/src/io/apc.rs
@@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     coords::WorldTileCoords,
+    error::Error,
     io::{
         scheduler::Scheduler,
         source_client::{HttpClient, HttpSourceClient, SourceClient},
@@ -42,7 +43,8 @@ pub enum Input {
 /// Allows sending messages from workers to back to the caller.
 pub trait Context<T: Transferables, HC: HttpClient>: Send + 'static {
     /// Send a message back to the caller.
-    fn send(&self, data: Message<T>);
+    // FIXME (wasm-executor): handle results send() calls
+    fn send(&self, data: Message<T>) -> Result<(), Error>;
 
     fn source_client(&self) -> &SourceClient<HC>;
 }
@@ -117,8 +119,8 @@ pub struct SchedulerContext<T: Transferables, HC: HttpClient> {
 }
 
 impl<T: Transferables, HC: HttpClient> Context<T, HC> for SchedulerContext<T, HC> {
-    fn send(&self, data: Message<T>) {
-        self.sender.send(data).unwrap(); // FIXME (wasm-executor): Remove unwrap
+    fn send(&self, data: Message<T>) -> Result<(), Error> {
+        self.sender.send(data).map_err(|e| Error::APC)
     }
 
     fn source_client(&self) -> &SourceClient<HC> {
@@ -156,7 +158,7 @@ impl<HC: HttpClient, S: Scheduler> AsyncProcedureCall<HC> for SchedulerAsyncProc
 
     fn call(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
         let sender = self.channel.0.clone();
-        let client = self.http_client.clone(); // FIXME (wasm-executor): do not clone each time
+        let client = self.http_client.clone(); // TODO (perf): do not clone each time
 
         self.scheduler
             .schedule(move || async move {
diff --git a/maplibre/src/io/pipeline.rs b/maplibre/src/io/pipeline.rs
index 04f491da..e3a5606c 100644
--- a/maplibre/src/io/pipeline.rs
+++ b/maplibre/src/io/pipeline.rs
@@ -5,28 +5,40 @@ use geozero::mvt::tile;
 
 use crate::{
     coords::WorldTileCoords,
+    error::Error,
     io::geometry_index::IndexedGeometry,
     render::ShaderVertex,
     tessellation::{IndexDataType, OverAlignedVertexBuffer},
 };
 
 /// Processes events which happen during the pipeline execution
+// FIXME (wasm-executor): handle results for messages below
 pub trait PipelineProcessor: Downcast {
-    fn tile_finished(&mut self, _coords: &WorldTileCoords) {}
-    fn layer_unavailable(&mut self, _coords: &WorldTileCoords, _layer_name: &str) {}
+    fn tile_finished(&mut self, _coords: &WorldTileCoords) -> Result<(), Error> {
+        Ok(())
+    }
+    fn layer_unavailable(
+        &mut self,
+        _coords: &WorldTileCoords,
+        _layer_name: &str,
+    ) -> Result<(), Error> {
+        Ok(())
+    }
     fn layer_tesselation_finished(
         &mut self,
         _coords: &WorldTileCoords,
         _buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
         _feature_indices: Vec<u32>,
         _layer_data: tile::Layer,
-    ) {
+    ) -> Result<(), Error> {
+        Ok(())
     }
     fn layer_indexing_finished(
         &mut self,
         _coords: &WorldTileCoords,
         _geometries: Vec<IndexedGeometry<f64>>,
-    ) {
+    ) -> Result<(), Error> {
+        Ok(())
     }
 }
 
diff --git a/maplibre/src/io/tile_pipelines.rs b/maplibre/src/io/tile_pipelines.rs
index d637fb62..a544b679 100644
--- a/maplibre/src/io/tile_pipelines.rs
+++ b/maplibre/src/io/tile_pipelines.rs
@@ -45,6 +45,7 @@ impl Processable for IndexLayer {
     ) -> Self::Output {
         let index = IndexProcessor::new();
 
+        // FIXME: Handle result
         context
             .processor_mut()
             .layer_indexing_finished(&tile_request.coords, index.get_geometries());
@@ -78,6 +79,7 @@ impl Processable for TessellateLayer {
 
             let mut tessellator = ZeroTessellator::<IndexDataType>::default();
             if let Err(e) = layer.process(&mut tessellator) {
+                // FIXME: Handle result
                 context
                     .processor_mut()
                     .layer_unavailable(coords, layer_name);
@@ -89,6 +91,7 @@ impl Processable for TessellateLayer {
                     e
                 );
             } else {
+                // FIXME: Handle result
                 context.processor_mut().layer_tesselation_finished(
                     coords,
                     tessellator.buffer.into(),
@@ -105,6 +108,7 @@ impl Processable for TessellateLayer {
             .collect::<HashSet<_>>();
 
         for missing_layer in tile_request.layers.difference(&available_layers) {
+            // FIXME: Handle result
             context
                 .processor_mut()
                 .layer_unavailable(coords, missing_layer);
@@ -118,6 +122,7 @@ impl Processable for TessellateLayer {
 
         tracing::info!("tile tessellated at {} finished", &tile_request.coords);
 
+        // FIXME: Handle result
         context.processor_mut().tile_finished(&tile_request.coords);
 
         (tile_request, tile)
diff --git a/maplibre/src/io/transferables.rs b/maplibre/src/io/transferables.rs
index b7a41321..0df01149 100644
--- a/maplibre/src/io/transferables.rs
+++ b/maplibre/src/io/transferables.rs
@@ -66,7 +66,7 @@ pub struct DefaultTessellatedLayer {
     pub buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
     /// Holds for each feature the count of indices.
     pub feature_indices: Vec<u32>,
-    pub layer_data: Layer, // FIXME (wasm-executor): Introduce a better structure for this
+    pub layer_data: Layer, // FIXME (perf): Introduce a better structure for this
 }
 
 impl TessellatedLayer for DefaultTessellatedLayer {
diff --git a/maplibre/src/stages/mod.rs b/maplibre/src/stages/mod.rs
index 14c45d4b..748f05dc 100644
--- a/maplibre/src/stages/mod.rs
+++ b/maplibre/src/stages/mod.rs
@@ -52,12 +52,16 @@ pub struct HeadedPipelineProcessor<T: Transferables, HC: HttpClient, C: Context<
 impl<'c, T: Transferables, HC: HttpClient, C: Context<T, HC>> PipelineProcessor
     for HeadedPipelineProcessor<T, HC, C>
 {
-    fn tile_finished(&mut self, coords: &WorldTileCoords) {
+    fn tile_finished(&mut self, coords: &WorldTileCoords) -> Result<(), Error> {
         self.context
             .send(Message::TileTessellated(T::TileTessellated::new(*coords)))
     }
 
-    fn layer_unavailable(&mut self, coords: &WorldTileCoords, layer_name: &str) {
+    fn layer_unavailable(
+        &mut self,
+        coords: &WorldTileCoords,
+        layer_name: &str,
+    ) -> Result<(), Error> {
         self.context
             .send(Message::UnavailableLayer(T::UnavailableLayer::new(
                 *coords,
@@ -71,7 +75,7 @@ impl<'c, T: Transferables, HC: HttpClient, C: Context<T, HC>> PipelineProcessor
         buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
         feature_indices: Vec<u32>,
         layer_data: tile::Layer,
-    ) {
+    ) -> Result<(), Error> {
         self.context
             .send(Message::TessellatedLayer(T::TessellatedLayer::new(
                 *coords,
diff --git a/maplibre/src/stages/request_stage.rs b/maplibre/src/stages/request_stage.rs
index afe0e13c..613920a9 100644
--- a/maplibre/src/stages/request_stage.rs
+++ b/maplibre/src/stages/request_stage.rs
@@ -106,6 +106,7 @@ pub fn schedule<
                 log::error!("{:?}", &e);
                 for to_load in &input.layers {
                     tracing::warn!("layer {} at {} unavailable", to_load, coords);
+                    // FIXME: Handle result
                     context.send(
                         Message::UnavailableLayer(<<E::AsyncProcedureCall as AsyncProcedureCall<
                             E::HttpClient,
diff --git a/maplibre/src/tessellation/mod.rs b/maplibre/src/tessellation/mod.rs
index 44d6ec78..03caf520 100644
--- a/maplibre/src/tessellation/mod.rs
+++ b/maplibre/src/tessellation/mod.rs
@@ -62,7 +62,6 @@ impl<V, I> OverAlignedVertexBuffer<V, I> {
         V: Copy,
         I: Copy,
     {
-        // FIXME (wasm-executor), make this fn not needed
         let mut buffers = VertexBuffers::with_capacity(0, 0);
         buffers.vertices = Vec::from(vertices);
         buffers.indices = Vec::from(indices);
diff --git a/web/src/platform/multithreaded/pool_scheduler.rs b/web/src/platform/multithreaded/pool_scheduler.rs
index b8a487af..6f68c571 100644
--- a/web/src/platform/multithreaded/pool_scheduler.rs
+++ b/web/src/platform/multithreaded/pool_scheduler.rs
@@ -13,19 +13,19 @@ pub struct WebWorkerPoolScheduler {
 
 impl WebWorkerPoolScheduler {
     pub fn new(new_worker: js_sys::Function) -> Self {
-        Self {
-            pool: WorkerPool::new(
-                1,
-                Box::new(move || {
-                    new_worker
-                        .call0(&JsValue::undefined())
-                        .unwrap() // FIXME (wasm-executor): Remove unwrap
-                        .dyn_into::<Worker>()
-                        .unwrap() // FIXME (wasm-executor): remove unwrap
-                }),
-            )
-            .unwrap(), // FIXME (wasm-executor): Remove unwrap
-        }
+        // TODO: Are expects here oke?
+        let pool = WorkerPool::new(
+            1,
+            Box::new(move || {
+                new_worker
+                    .call0(&JsValue::undefined())
+                    .expect("Unable to call new_worker function")
+                    .dyn_into::<Worker>()
+                    .expect("new_worker function did not return a Worker")
+            }),
+        )
+        .expect("Unable to create WorkerPool");
+        Self { pool }
     }
 }
 
diff --git a/web/src/platform/singlethreaded/apc.rs b/web/src/platform/singlethreaded/apc.rs
index 1b7f5ee4..957add24 100644
--- a/web/src/platform/singlethreaded/apc.rs
+++ b/web/src/platform/singlethreaded/apc.rs
@@ -18,6 +18,7 @@ use std::{
 use js_sys::Uint8Array;
 use maplibre::{
     environment::Environment,
+    error::Error,
     io::{
         apc::{AsyncProcedure, AsyncProcedureCall, Context, Input, Message},
         scheduler::Scheduler,
@@ -120,7 +121,7 @@ pub struct PassingContext {
 }
 
 impl Context<UsedTransferables, UsedHttpClient> for PassingContext {
-    fn send(&self, data: Message<UsedTransferables>) {
+    fn send(&self, data: Message<UsedTransferables>) -> Result<(), Error> {
         let tag = data.tag();
         let serialized = data.serialize();
 
@@ -130,11 +131,13 @@ impl Context<UsedTransferables, UsedHttpClient> for PassingContext {
             serialized_array.set(&Uint8Array::view(serialized), 0);
         }
 
-        let global = js_sys::global().unchecked_into::<DedicatedWorkerGlobalScope>(); // FIXME (wasm-executor): Remove unchecked
+        let global = js_sys::global()
+            .try_into::<DedicatedWorkerGlobalScope>()
+            .map_err(|e| Error::APC);
         let array = js_sys::Array::new();
         array.push(&JsValue::from(tag as u32));
         array.push(&serialized_array_buffer);
-        global.post_message(&array).unwrap(); // FIXME (wasm-executor) Remove unwrap
+        global.post_message(&array).map_err(|e| Error::APC)
     }
 
     fn source_client(&self) -> &SourceClient<UsedHttpClient> {
diff --git a/web/src/platform/singlethreaded/transferables.rs b/web/src/platform/singlethreaded/transferables.rs
index b1abf036..dc5105f7 100644
--- a/web/src/platform/singlethreaded/transferables.rs
+++ b/web/src/platform/singlethreaded/transferables.rs
@@ -131,7 +131,8 @@ impl TessellatedLayer for LinearTessellatedLayer {
     }
 
     fn to_stored_layer(self) -> StoredLayer {
-        let layer = StoredLayer::TessellatedLayer {
+        // TODO: Avoid copies here
+        StoredLayer::TessellatedLayer {
             coords: WrapperWorldTileCoords::peel(self.data.coords),
             layer_name: String::from_utf8(Vec::from(
                 &self.data.layer_name[..self.data.layer_name_len],
@@ -143,9 +144,7 @@ impl TessellatedLayer for LinearTessellatedLayer {
                 self.data.usable_indices,
             ),
             feature_indices: Vec::from(&self.data.feature_indices[..self.data.feature_indices_len]),
-        };
-
-        layer
+        }
     }
 }
 

From 8645a506ea9179a1817eaa118ec36593a7327dff Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 21:09:02 +0100
Subject: [PATCH 15/31] Fix compilation issues

---
 maplibre-winit/src/noweb.rs       | 26 +++++++++++++++-----------
 maplibre/src/headless/map.rs      |  5 +++--
 maplibre/src/io/tile_pipelines.rs |  2 +-
 maplibre/src/stages/mod.rs        |  3 ++-
 web/src/lib.rs                    |  6 ++----
 5 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/maplibre-winit/src/noweb.rs b/maplibre-winit/src/noweb.rs
index 0849b968..62a3b35d 100644
--- a/maplibre-winit/src/noweb.rs
+++ b/maplibre-winit/src/noweb.rs
@@ -10,7 +10,7 @@ use maplibre::{
     kernel::{Kernel, KernelBuilder},
     map::Map,
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
-    render::builder::RenderBuilder,
+    render::builder::{InitializedRenderer, RenderBuilder},
     style::Style,
     window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
 };
@@ -82,19 +82,23 @@ pub fn run_headed_map(cache_path: Option<String>) {
             .with_scheduler(TokioScheduler::new())
             .build();
 
-        let uninitialized = RenderBuilder::new()
+        let InitializedRenderer {
+            mut window,
+            renderer,
+        } = RenderBuilder::new()
             .build()
             .initialize_with(&kernel)
             .await
-            .expect("Failed to initialize renderer");
-        let result = uninitialized.unwarp();
+            .expect("Failed to initialize renderer")
+            .unwarp();
 
-        let mut window = result.window;
-        let renderer = result.renderer;
-        window.event_loop.take().unwrap().run(
-            window,
-            Map::new(Style::default(), kernel, renderer).unwrap(),
-            None,
-        )
+        window
+            .take_event_loop()
+            .expect("Event loop is not available")
+            .run(
+                window,
+                Map::new(Style::default(), kernel, renderer).unwrap(),
+                None,
+            )
     })
 }
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index 00433bd4..ac4d38de 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -139,12 +139,13 @@ impl PipelineProcessor for HeadlessPipelineProcessor {
         buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
         feature_indices: Vec<u32>,
         layer_data: RawLayer,
-    ) {
+    ) -> Result<(), Error> {
         self.layers.push(StoredLayer::TessellatedLayer {
             coords: *coords,
             layer_name: layer_data.name,
             buffer,
             feature_indices,
-        })
+        });
+        Ok(())
     }
 }
diff --git a/maplibre/src/io/tile_pipelines.rs b/maplibre/src/io/tile_pipelines.rs
index a544b679..a8104386 100644
--- a/maplibre/src/io/tile_pipelines.rs
+++ b/maplibre/src/io/tile_pipelines.rs
@@ -97,7 +97,7 @@ impl Processable for TessellateLayer {
                     tessellator.buffer.into(),
                     tessellator.feature_indices,
                     cloned_layer,
-                )
+                );
             }
         }
 
diff --git a/maplibre/src/stages/mod.rs b/maplibre/src/stages/mod.rs
index 748f05dc..593d83ae 100644
--- a/maplibre/src/stages/mod.rs
+++ b/maplibre/src/stages/mod.rs
@@ -89,11 +89,12 @@ impl<'c, T: Transferables, HC: HttpClient, C: Context<T, HC>> PipelineProcessor
         &mut self,
         coords: &WorldTileCoords,
         geometries: Vec<IndexedGeometry<f64>>,
-    ) {
+    ) -> Result<(), Error> {
         // FIXME (wasm-executor): Readd
         /*        if let Ok(mut geometry_index) = self.state.geometry_index.lock() {
             geometry_index.index_tile(coords, TileIndex::Linear { list: geometries })
         }*/
+        Ok(())
     }
 }
 
diff --git a/web/src/lib.rs b/web/src/lib.rs
index 2e54d83e..ea376346 100644
--- a/web/src/lib.rs
+++ b/web/src/lib.rs
@@ -63,7 +63,6 @@ pub type MapType = Map<
 
 #[wasm_bindgen]
 pub async fn create_map(new_worker: js_sys::Function) -> u32 {
-    // Either call forget or the main loop to keep worker loop alive
     let mut builder = MapBuilder::new()
         .with_map_window_config(WinitMapWindowConfig::new("maplibre".to_string()))
         .with_http_client(WHATWGFetchHttpClient::new());
@@ -97,9 +96,8 @@ pub async fn create_map(new_worker: js_sys::Function) -> u32 {
 #[wasm_bindgen]
 pub unsafe fn clone_map(map_ptr: *const RefCell<MapType>) -> *const RefCell<MapType> {
     let mut map = Rc::from_raw(map_ptr);
-    let rc = map.clone();
-    let cloned = Rc::into_raw(rc);
-    mem::forget(map);
+    let cloned = Rc::into_raw(map.clone());
+    mem::forget(map); // TODO: Enforce forget, else the map gets dropped after calling such a function
     cloned
 }
 

From 8af27b29cf53c4a03c70426b7e22d7eca3a283a0 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Sun, 30 Oct 2022 22:10:08 +0100
Subject: [PATCH 16/31] Fix web compilation issues

---
 benchmarks/benches/render.rs               | 50 ++++++-------
 maplibre-demo/src/headless.rs              | 21 +-----
 maplibre-winit/Cargo.toml                  |  2 +-
 maplibre-winit/src/lib.rs                  | 45 ++++-------
 maplibre-winit/src/noweb.rs                | 36 ++++-----
 maplibre-winit/src/web.rs                  | 40 ++++++----
 maplibre/src/headless/mod.rs               | 35 +++++++++
 maplibre/src/io/tile_repository.rs         |  4 +-
 maplibre/src/map.rs                        |  4 +
 maplibre/src/platform/noweb/http_client.rs |  1 +
 web/lib/build.mjs                          | 10 +--
 web/lib/src/index.ts                       | 15 ++--
 web/src/lib.rs                             | 87 +++++++++++++---------
 web/src/platform/singlethreaded/apc.rs     | 33 ++++----
 14 files changed, 208 insertions(+), 175 deletions(-)

diff --git a/benchmarks/benches/render.rs b/benchmarks/benches/render.rs
index dce73caf..b231a730 100644
--- a/benchmarks/benches/render.rs
+++ b/benchmarks/benches/render.rs
@@ -4,7 +4,10 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use maplibre::{
     coords::{WorldTileCoords, ZoomLevel},
     error::Error,
-    headless::{utils::HeadlessPipelineProcessor, HeadlessEnvironment, HeadlessMapWindowConfig},
+    headless::{
+        create_headless_renderer, environment::HeadlessEnvironment, map::HeadlessMap,
+        window::HeadlessMapWindowConfig,
+    },
     io::{
         apc::SchedulerAsyncProcedureCall,
         pipeline::{PipelineContext, Processable},
@@ -12,43 +15,32 @@ use maplibre::{
         tile_pipelines::build_vector_tile_pipeline,
         TileRequest,
     },
+    kernel::{Kernel, KernelBuilder},
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
-    render::settings::{RendererSettings, TextureFormat},
+    render::{
+        builder::{InitializedRenderer, RenderBuilder},
+        settings::{RendererSettings, TextureFormat},
+    },
+    style::Style,
     window::WindowSize,
-    MapBuilder,
 };
 
 fn headless_render(c: &mut Criterion) {
     c.bench_function("headless_render", |b| {
-        let mut map = run_multithreaded(async {
-            let client = ReqwestHttpClient::new(None);
+        let (mut map, tile) = run_multithreaded(async {
+            let (kernel, renderer) = create_headless_renderer(1000, None).await;
+            let style = Style::default();
+            let mut map = HeadlessMap::new(style, renderer, kernel).unwrap();
 
-            let mut map = MapBuilder::<
-                HeadlessEnvironment<_, _, _, SchedulerAsyncProcedureCall<_, _>>,
-            >::new()
-            .with_map_window_config(HeadlessMapWindowConfig {
-                size: WindowSize::new(1000, 1000).unwrap(),
-            })
-            .with_http_client(client.clone())
-            .with_apc(SchedulerAsyncProcedureCall::new(
-                client,
-                TokioScheduler::new(),
-            ))
-            .with_scheduler(TokioScheduler::new())
-            .with_renderer_settings(RendererSettings {
-                texture_format: TextureFormat::Rgba8UnormSrgb,
-                ..RendererSettings::default()
-            })
-            .build()
-            .initialize_headless()
-            .await;
-
-            map.map_schedule
-                .fetch_process(&WorldTileCoords::from((0, 0, ZoomLevel::default())))
+            let tile = map
+                .fetch_tile(
+                    WorldTileCoords::from((0, 0, ZoomLevel::default())),
+                    &["water"],
+                )
                 .await
                 .expect("Failed to fetch and process!");
 
-            map
+            (map, tile)
         });
 
         b.to_async(
@@ -58,7 +50,7 @@ fn headless_render(c: &mut Criterion) {
                 .unwrap(),
         )
         .iter(|| {
-            match map.map_schedule_mut().update_and_redraw() {
+            match map.render_tile(tile.clone()) {
                 Ok(_) => {}
                 Err(Error::Render(e)) => {
                     eprintln!("{}", e);
diff --git a/maplibre-demo/src/headless.rs b/maplibre-demo/src/headless.rs
index 633fc2ec..a26e7d2b 100644
--- a/maplibre-demo/src/headless.rs
+++ b/maplibre-demo/src/headless.rs
@@ -1,7 +1,7 @@
 use maplibre::{
     coords::{LatLon, WorldTileCoords},
     error::Error,
-    headless::{map::HeadlessMap, window::HeadlessMapWindowConfig},
+    headless::{create_headless_renderer, map::HeadlessMap, window::HeadlessMapWindowConfig},
     io::apc::SchedulerAsyncProcedureCall,
     kernel::KernelBuilder,
     platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
@@ -17,24 +17,7 @@ use maplibre_winit::WinitEnvironment;
 use tile_grid::{extent_wgs84_to_merc, Extent, GridIterator};
 
 pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
-    let client = ReqwestHttpClient::new(None);
-    let kernel = KernelBuilder::new()
-        .with_map_window_config(HeadlessMapWindowConfig::new(
-            WindowSize::new(tile_size, tile_size).unwrap(),
-        ))
-        .with_http_client(client.clone())
-        .with_apc(SchedulerAsyncProcedureCall::new(
-            client,
-            TokioScheduler::new(),
-        ))
-        .with_scheduler(TokioScheduler::new())
-        .build();
-
-    let renderer = RenderBuilder::new()
-        .build()
-        .initialize_headless_with(&kernel)
-        .await
-        .expect("Failed to initialize renderer");
+    let (kernel, renderer) = create_headless_renderer(tile_size, None).await;
 
     let style = Style::default();
 
diff --git a/maplibre-winit/Cargo.toml b/maplibre-winit/Cargo.toml
index e817cac7..6add2389 100644
--- a/maplibre-winit/Cargo.toml
+++ b/maplibre-winit/Cargo.toml
@@ -18,7 +18,7 @@ wasm-bindgen = "0.2.81"
 wasm-bindgen-futures = "0.4.31"
 
 [dependencies]
-maplibre = { path = "../maplibre", version = "0.0.2" }
+maplibre = { path = "../maplibre", version = "0.0.2", default-features = false }
 winit = { version = "0.27.2", default-features = false }
 cgmath = "0.18.0"
 instant = { version = "0.1.12", features = ["wasm-bindgen"] } # TODO: Untrusted dependency
diff --git a/maplibre-winit/src/lib.rs b/maplibre-winit/src/lib.rs
index b3a6c15b..85306359 100644
--- a/maplibre-winit/src/lib.rs
+++ b/maplibre-winit/src/lib.rs
@@ -38,35 +38,6 @@ pub use noweb::*;
 #[cfg(target_arch = "wasm32")]
 pub use web::*;
 
-#[cfg(not(target_arch = "wasm32"))]
-pub struct WinitMapWindowConfig<ET> {
-    title: String,
-
-    phantom_et: PhantomData<ET>,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl<ET> WinitMapWindowConfig<ET> {
-    pub fn new(title: String) -> Self {
-        Self {
-            title,
-            phantom_et: Default::default(),
-        }
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-pub struct WinitMapWindowConfig {
-    canvas_id: String,
-}
-
-#[cfg(target_arch = "wasm32")]
-impl WinitMapWindowConfig {
-    pub fn new(canvas_id: String) -> Self {
-        Self { canvas_id }
-    }
-}
-
 pub struct WinitMapWindow<ET: 'static> {
     window: RawWinitWindow,
     event_loop: Option<WinitEventLoop<ET>>,
@@ -78,6 +49,22 @@ impl<ET> WinitMapWindow<ET> {
     }
 }
 
+impl<ET> HeadedMapWindow for WinitMapWindow<ET> {
+    type RawWindow = RawWinitWindow;
+
+    fn raw(&self) -> &Self::RawWindow {
+        &self.window
+    }
+
+    fn request_redraw(&self) {
+        self.window.request_redraw()
+    }
+
+    fn id(&self) -> u64 {
+        self.window.id().into()
+    }
+}
+
 pub struct WinitEventLoop<ET: 'static> {
     event_loop: RawWinitEventLoop<ET>,
 }
diff --git a/maplibre-winit/src/noweb.rs b/maplibre-winit/src/noweb.rs
index 62a3b35d..8026a051 100644
--- a/maplibre-winit/src/noweb.rs
+++ b/maplibre-winit/src/noweb.rs
@@ -3,6 +3,8 @@
 //! * Platform Events like suspend/resume
 //! * Render a new frame
 
+use std::marker::PhantomData;
+
 use maplibre::{
     event_loop::EventLoop,
     headless::map::HeadlessMap,
@@ -16,10 +18,25 @@ use maplibre::{
 };
 use winit::window::WindowBuilder;
 
-use super::{RawWinitEventLoop, RawWinitWindow, WinitMapWindow, WinitMapWindowConfig};
+use super::{RawWinitEventLoop, RawWinitWindow, WinitMapWindow};
 use crate::{WinitEnvironment, WinitEventLoop};
 
-impl<T> MapWindow for WinitMapWindow<T> {
+pub struct WinitMapWindowConfig<ET> {
+    title: String,
+
+    phantom_et: PhantomData<ET>,
+}
+
+impl<ET> WinitMapWindowConfig<ET> {
+    pub fn new(title: String) -> Self {
+        Self {
+            title,
+            phantom_et: Default::default(),
+        }
+    }
+}
+
+impl<ET> MapWindow for WinitMapWindow<ET> {
     fn size(&self) -> WindowSize {
         let size = self.window.inner_size();
         #[cfg(target_os = "android")]
@@ -34,21 +51,6 @@ impl<T> MapWindow for WinitMapWindow<T> {
         window_size
     }
 }
-impl<T> HeadedMapWindow for WinitMapWindow<T> {
-    type RawWindow = RawWinitWindow;
-
-    fn raw(&self) -> &Self::RawWindow {
-        &self.window
-    }
-
-    fn request_redraw(&self) {
-        self.window.request_redraw()
-    }
-
-    fn id(&self) -> u64 {
-        self.window.id().into()
-    }
-}
 
 impl<ET: 'static> MapWindowConfig for WinitMapWindowConfig<ET> {
     type MapWindow = WinitMapWindow<ET>;
diff --git a/maplibre-winit/src/web.rs b/maplibre-winit/src/web.rs
index 44bfeaf4..913bc54b 100644
--- a/maplibre-winit/src/web.rs
+++ b/maplibre-winit/src/web.rs
@@ -1,42 +1,54 @@
+use std::marker::PhantomData;
+
 use maplibre::window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize};
 use winit::{platform::web::WindowBuilderExtWebSys, window::WindowBuilder};
 
-use super::{RawWinitEventLoop, RawWinitWindow, WinitMapWindow, WinitMapWindowConfig};
+use super::{RawWinitEventLoop, RawWinitWindow, WinitMapWindow};
+use crate::WinitEventLoop;
 
-impl MapWindowConfig for WinitMapWindowConfig {
-    type MapWindow = WinitMapWindow;
+pub struct WinitMapWindowConfig<ET> {
+    canvas_id: String,
+    phantom_et: PhantomData<ET>,
+}
+
+impl<ET: 'static> WinitMapWindowConfig<ET> {
+    pub fn new(canvas_id: String) -> Self {
+        Self {
+            canvas_id,
+            phantom_et: Default::default(),
+        }
+    }
+}
+
+impl<ET: 'static> MapWindowConfig for WinitMapWindowConfig<ET> {
+    type MapWindow = WinitMapWindow<ET>;
 
     fn create(&self) -> Self::MapWindow {
-        let event_loop = RawWinitEventLoop::new();
+        let raw_event_loop = winit::event_loop::EventLoopBuilder::<ET>::with_user_event().build();
 
         let window: winit::window::Window = WindowBuilder::new()
             .with_canvas(Some(get_canvas(&self.canvas_id)))
-            .build(&event_loop)
+            .build(&raw_event_loop)
             .unwrap();
 
         let size = get_body_size().unwrap();
         window.set_inner_size(size);
         Self::MapWindow {
             window,
-            event_loop: Some(event_loop),
+            event_loop: Some(WinitEventLoop {
+                event_loop: raw_event_loop,
+            }),
         }
     }
 }
 
-impl MapWindow for WinitMapWindow {
+impl<ET: 'static> MapWindow for WinitMapWindow<ET> {
     fn size(&self) -> WindowSize {
         let size = self.window.inner_size();
 
         WindowSize::new(size.width, size.height).expect("failed to get window dimensions.")
     }
 }
-impl HeadedMapWindow for WinitMapWindow {
-    type RawWindow = RawWinitWindow;
-
-    fn raw(&self) -> &Self::RawWindow {
-        &self.window
-    }
-}
 
 pub fn get_body_size() -> Option<winit::dpi::LogicalSize<i32>> {
     let web_window: web_sys::Window = web_sys::window().unwrap();
diff --git a/maplibre/src/headless/mod.rs b/maplibre/src/headless/mod.rs
index 3b7eefbc..fb9ed25d 100644
--- a/maplibre/src/headless/mod.rs
+++ b/maplibre/src/headless/mod.rs
@@ -1,6 +1,41 @@
+use crate::{
+    headless::{environment::HeadlessEnvironment, window::HeadlessMapWindowConfig},
+    io::apc::SchedulerAsyncProcedureCall,
+    kernel::{Kernel, KernelBuilder},
+    platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
+    render::{builder::RenderBuilder, Renderer},
+    window::WindowSize,
+};
+
 mod graph_node;
 mod stage;
 
 pub mod environment;
 pub mod map;
 pub mod window;
+
+pub async fn create_headless_renderer(
+    tile_size: u32,
+    cache_path: Option<String>,
+) -> (Kernel<HeadlessEnvironment>, Renderer) {
+    let client = ReqwestHttpClient::new(cache_path);
+    let kernel = KernelBuilder::new()
+        .with_map_window_config(HeadlessMapWindowConfig::new(
+            WindowSize::new(tile_size, tile_size).unwrap(),
+        ))
+        .with_http_client(client.clone())
+        .with_apc(SchedulerAsyncProcedureCall::new(
+            client,
+            TokioScheduler::new(),
+        ))
+        .with_scheduler(TokioScheduler::new())
+        .build();
+
+    let renderer = RenderBuilder::new()
+        .build()
+        .initialize_headless_with(&kernel)
+        .await
+        .expect("Failed to initialize renderer");
+
+    (kernel, renderer)
+}
diff --git a/maplibre/src/io/tile_repository.rs b/maplibre/src/io/tile_repository.rs
index 714d73a8..ac4d7e46 100644
--- a/maplibre/src/io/tile_repository.rs
+++ b/maplibre/src/io/tile_repository.rs
@@ -11,6 +11,7 @@ use crate::{
 };
 
 /// A layer which is stored for future use.
+#[derive(Clone)]
 pub enum StoredLayer {
     UnavailableLayer {
         coords: WorldTileCoords,
@@ -41,7 +42,7 @@ impl StoredLayer {
     }
 }
 
-#[derive(Eq, PartialEq)]
+#[derive(Clone, Copy, Eq, PartialEq)]
 pub enum TileStatus {
     Pending,
     Failed,
@@ -49,6 +50,7 @@ pub enum TileStatus {
 }
 
 /// Stores multiple [StoredLayers](StoredLayer).
+#[derive(Clone)]
 pub struct StoredTile {
     coords: WorldTileCoords,
     layers: Vec<StoredLayer>,
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index d8b119b6..178a6dce 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -64,4 +64,8 @@ impl<E: Environment> Map<E> {
     pub fn context_mut(&mut self) -> &mut MapContext {
         &mut self.map_context
     }
+
+    pub fn kernel(&self) -> &Rc<Kernel<E>> {
+        &self.kernel
+    }
 }
diff --git a/maplibre/src/platform/noweb/http_client.rs b/maplibre/src/platform/noweb/http_client.rs
index 5ebd8153..ef230faa 100644
--- a/maplibre/src/platform/noweb/http_client.rs
+++ b/maplibre/src/platform/noweb/http_client.rs
@@ -23,6 +23,7 @@ impl From<reqwest_middleware::Error> for Error {
 
 impl ReqwestHttpClient {
     /// cache_path: Under which path should we cache requests.
+    // TODO: Use Into<Path> instead of String
     pub fn new(cache_path: Option<String>) -> Self {
         let mut builder = reqwest_middleware::ClientBuilder::new(Client::new());
 
diff --git a/web/lib/build.mjs b/web/lib/build.mjs
index b370c288..fb2571df 100644
--- a/web/lib/build.mjs
+++ b/web/lib/build.mjs
@@ -237,6 +237,7 @@ const esbuild = async (name, globalName = undefined) => {
 }
 
 const start = async () => {
+    try {
     console.log("Creating WASM...")
     wasmPack();
 
@@ -257,10 +258,9 @@ const start = async () => {
 
     console.log("Emitting TypeScript types...")
     emitTypeScript();
+    } catch (e) {
+        console.error("Failed to start building: " + e.message)
+    }
 }
 
-try {
-    const _ = start()
-} catch (e) {
-    console.log("Failed to start building: " + e.message)
-}
+const _ = start()
diff --git a/web/lib/src/index.ts b/web/lib/src/index.ts
index c5e95abd..5b3ebf8d 100644
--- a/web/lib/src/index.ts
+++ b/web/lib/src/index.ts
@@ -31,18 +31,19 @@ export const startMapLibre = async (wasmPath: string | undefined, workerPath: st
         const memory = new WebAssembly.Memory({initial: 1024, maximum: MEMORY / PAGES, shared: true})
         await maplibre.default(wasmPath, memory)
 
-        maplibre.run(await maplibre.create_map(() => {
+        let init_result = await maplibre.init_maplibre(() => {
             return workerPath ? new Worker(workerPath, {
                 type: 'module'
             }) : MultithreadedPoolWorker();
-        }))
+        });
+        maplibre.run(init_result)
     } else {
         const memory = new WebAssembly.Memory({initial: 1024, shared: false})
         await maplibre.default(wasmPath, memory);
 
         let callbacks: {worker_callback?: (message: MessageEvent) => void} = {}
 
-        let map = await maplibre.create_map(() => {
+        let init_result = await maplibre.init_maplibre(() => {
             let worker: Worker = workerPath ? new Worker(workerPath, {
                 type: 'module'
             }) : PoolWorker();
@@ -54,16 +55,16 @@ export const startMapLibre = async (wasmPath: string | undefined, workerPath: st
             return worker;
         })
 
-        let clonedMap = maplibre.clone_map(map)
+        // MAJOR FIXME: cloning is not possible let clonedMap = maplibre.clone_map(init_result)
 
-        callbacks.worker_callback = (message) => {
+        /*callbacks.worker_callback = (message) => {
             let tag = message.data[0];
             let data = new Uint8Array(message.data[1]);
 
             // @ts-ignore TODO unsync_main_entry may not be defined
             maplibre.singlethreaded_main_entry(clonedMap, tag, data)
-        }
+        }*/
 
-        maplibre.run(map)
+        maplibre.run(init_result)
     }
 }
diff --git a/web/src/lib.rs b/web/src/lib.rs
index ea376346..18256d6b 100644
--- a/web/src/lib.rs
+++ b/web/src/lib.rs
@@ -1,8 +1,15 @@
 #![feature(allocator_api, new_uninit)]
 
-use std::{borrow::BorrowMut, cell::RefCell, mem, ops::Deref, panic, rc::Rc};
+use std::{borrow::BorrowMut, cell::RefCell, mem, ops::Deref, rc::Rc};
 
-use maplibre::{io::scheduler::NopScheduler, Map, MapBuilder};
+use maplibre::{
+    event_loop::EventLoop,
+    io::{apc::SchedulerAsyncProcedureCall, scheduler::NopScheduler},
+    kernel::{Kernel, KernelBuilder},
+    map::Map,
+    render::builder::{InitializedRenderer, RenderBuilder},
+    style::Style,
+};
 use maplibre_winit::{WinitEnvironment, WinitMapWindowConfig};
 use wasm_bindgen::prelude::*;
 
@@ -32,44 +39,47 @@ pub fn wasm_bindgen_start() {
     if console_log::init_with_level(log::Level::Info).is_err() {
         // Failed to initialize logging. No need to log a message.
     }
-    panic::set_hook(Box::new(console_error_panic_hook::hook));
+    std::panic::set_hook(Box::new(console_error_panic_hook::hook));
 
     #[cfg(any(feature = "trace"))]
     enable_tracing();
 }
 
 #[cfg(not(target_feature = "atomics"))]
-pub type MapType = Map<
-    WinitEnvironment<
-        NopScheduler,
-        WHATWGFetchHttpClient,
-        platform::singlethreaded::transferables::LinearTransferables,
-        platform::singlethreaded::apc::PassingAsyncProcedureCall,
-    >,
+type CurrentEnvironment = WinitEnvironment<
+    NopScheduler,
+    WHATWGFetchHttpClient,
+    platform::singlethreaded::apc::PassingAsyncProcedureCall,
+    (),
 >;
 
 #[cfg(target_feature = "atomics")]
-pub type MapType = Map<
-    WinitEnvironment<
-        platform::multithreaded::pool_scheduler::WebWorkerPoolScheduler,
+type CurrentEnvironment = WinitEnvironment<
+    platform::multithreaded::pool_scheduler::WebWorkerPoolScheduler,
+    WHATWGFetchHttpClient,
+    maplibre::io::apc::SchedulerAsyncProcedureCall<
         WHATWGFetchHttpClient,
-        maplibre::io::transferables::DefaultTransferables,
-        maplibre::io::apc::SchedulerAsyncProcedureCall<
-            WHATWGFetchHttpClient,
-            platform::multithreaded::pool_scheduler::WebWorkerPoolScheduler,
-        >,
+        platform::multithreaded::pool_scheduler::WebWorkerPoolScheduler,
     >,
+    (),
 >;
 
+pub type MapType = Map<CurrentEnvironment>;
+
+pub struct InitResult {
+    initialized: InitializedRenderer<WinitMapWindowConfig<()>>,
+    kernel: Kernel<CurrentEnvironment>,
+}
+
 #[wasm_bindgen]
-pub async fn create_map(new_worker: js_sys::Function) -> u32 {
-    let mut builder = MapBuilder::new()
+pub async fn init_maplibre(new_worker: js_sys::Function) -> u32 {
+    let mut kernel_builder = KernelBuilder::new()
         .with_map_window_config(WinitMapWindowConfig::new("maplibre".to_string()))
         .with_http_client(WHATWGFetchHttpClient::new());
 
     #[cfg(target_feature = "atomics")]
     {
-        builder = builder
+        kernel_builder = kernel_builder
             .with_apc(maplibre::io::apc::SchedulerAsyncProcedureCall::new(
                 WHATWGFetchHttpClient::new(),
                 platform::multithreaded::pool_scheduler::WebWorkerPoolScheduler::new(
@@ -83,29 +93,38 @@ pub async fn create_map(new_worker: js_sys::Function) -> u32 {
 
     #[cfg(not(target_feature = "atomics"))]
     {
-        builder = builder
+        kernel_builder = kernel_builder
             .with_apc(platform::singlethreaded::apc::PassingAsyncProcedureCall::new(new_worker, 4))
             .with_scheduler(NopScheduler);
     }
 
-    let map: MapType = builder.build().initialize().await;
+    let kernel: Kernel<WinitEnvironment<_, _, _, ()>> = kernel_builder.build();
 
-    Rc::into_raw(Rc::new(RefCell::new(map))) as u32
+    Box::into_raw(Box::new(InitResult {
+        initialized: RenderBuilder::new()
+            .build()
+            .initialize_with(&kernel)
+            .await
+            .expect("Failed to initialize renderer")
+            .unwarp(),
+        kernel,
+    })) as u32
 }
 
 #[wasm_bindgen]
-pub unsafe fn clone_map(map_ptr: *const RefCell<MapType>) -> *const RefCell<MapType> {
-    let mut map = Rc::from_raw(map_ptr);
-    let cloned = Rc::into_raw(map.clone());
-    mem::forget(map); // TODO: Enforce forget, else the map gets dropped after calling such a function
-    cloned
-}
+pub unsafe fn run(init_ptr: *mut InitResult) {
+    let mut init_result = Box::from_raw(init_ptr);
 
-#[wasm_bindgen]
-pub unsafe fn run(map_ptr: *const RefCell<MapType>) {
-    let mut map = Rc::from_raw(map_ptr);
+    let InitializedRenderer {
+        mut window,
+        renderer,
+    } = init_result.initialized;
+    let map: MapType = Map::new(Style::default(), init_result.kernel, renderer).unwrap();
 
-    map.deref().borrow().run();
+    window
+        .take_event_loop()
+        .expect("Event loop is not available")
+        .run(window, map, None)
 }
 
 #[cfg(test)]
diff --git a/web/src/platform/singlethreaded/apc.rs b/web/src/platform/singlethreaded/apc.rs
index 957add24..960dd400 100644
--- a/web/src/platform/singlethreaded/apc.rs
+++ b/web/src/platform/singlethreaded/apc.rs
@@ -131,9 +131,8 @@ impl Context<UsedTransferables, UsedHttpClient> for PassingContext {
             serialized_array.set(&Uint8Array::view(serialized), 0);
         }
 
-        let global = js_sys::global()
-            .try_into::<DedicatedWorkerGlobalScope>()
-            .map_err(|e| Error::APC);
+        let global: DedicatedWorkerGlobalScope =
+            js_sys::global().dyn_into().map_err(|e| Error::APC)?;
         let array = js_sys::Array::new();
         array.push(&JsValue::from(tag as u32));
         array.push(&serialized_array_buffer);
@@ -149,7 +148,7 @@ pub struct PassingAsyncProcedureCall {
     new_worker: Box<dyn Fn() -> Worker>,
     workers: Vec<Worker>,
 
-    received: Vec<Message<UsedTransferables>>,
+    received: RefCell<Vec<Message<UsedTransferables>>>, // FIXME (wasm-executor): Is RefCell fine?
 }
 
 impl PassingAsyncProcedureCall {
@@ -176,16 +175,17 @@ impl PassingAsyncProcedureCall {
         Self {
             new_worker: create_new_worker,
             workers,
-            received: vec![],
+            received: RefCell::new(vec![]),
         }
     }
 }
 
-impl AsyncProcedureCall<UsedTransferables, UsedHttpClient> for PassingAsyncProcedureCall {
+impl AsyncProcedureCall<UsedHttpClient> for PassingAsyncProcedureCall {
     type Context = UsedContext;
+    type Transferables = UsedTransferables;
 
-    fn receive(&mut self) -> Option<Message<UsedTransferables>> {
-        self.received.pop()
+    fn receive(&self) -> Option<Message<UsedTransferables>> {
+        self.received.borrow_mut().pop()
     }
 
     fn call(&self, input: Input, procedure: AsyncProcedure<Self::Context>) {
@@ -208,7 +208,7 @@ pub async fn singlethreaded_worker_entry(procedure_ptr: u32, input: String) -> R
     let input = serde_json::from_str::<Input>(&input).unwrap(); // FIXME (wasm-executor): Remove unwrap
 
     let context = PassingContext {
-        source_client: SourceClient::Http(HttpSourceClient::new(WHATWGFetchHttpClient::new())),
+        source_client: SourceClient::new(HttpSourceClient::new(WHATWGFetchHttpClient::new())),
     };
 
     (procedure)(input, context).await;
@@ -231,16 +231,11 @@ pub unsafe fn singlethreaded_main_entry(
         data,
     );
 
-    map.deref()
-        .borrow()
-        .map_schedule()
-        .deref()
-        .borrow()
-        .apc
-        .deref()
-        .borrow_mut()
-        .received
-        .push(message);
+    let map = map.deref().borrow();
+    let kernel = map.kernel();
+
+    // MAJOR FIXME: Fix mutability
+    // kernel.apc().received.push(message);
 
     mem::forget(map); // FIXME (wasm-executor): Enforce this somehow
 

From d835ef461fec59b121fa01927a57780a24a29796 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Mon, 31 Oct 2022 09:32:47 +0100
Subject: [PATCH 17/31] Fix non-multithreaded web target

---
 web/lib/src/index.ts                          | 20 ++----
 .../platform/multithreaded/pool_scheduler.rs  |  1 +
 web/src/platform/singlethreaded/apc.rs        | 32 ++++++---
 .../platform/singlethreaded/transferables.rs  | 70 +++++++++++++++++++
 4 files changed, 98 insertions(+), 25 deletions(-)

diff --git a/web/lib/src/index.ts b/web/lib/src/index.ts
index 5b3ebf8d..220df44b 100644
--- a/web/lib/src/index.ts
+++ b/web/lib/src/index.ts
@@ -41,30 +41,22 @@ export const startMapLibre = async (wasmPath: string | undefined, workerPath: st
         const memory = new WebAssembly.Memory({initial: 1024, shared: false})
         await maplibre.default(wasmPath, memory);
 
-        let callbacks: {worker_callback?: (message: MessageEvent) => void} = {}
-
-        let init_result = await maplibre.init_maplibre(() => {
+        let init_result = await maplibre.init_maplibre((ptr) => {
             let worker: Worker = workerPath ? new Worker(workerPath, {
                 type: 'module'
             }) : PoolWorker();
 
             worker.onmessage = (message: MessageEvent) => {
-                callbacks.worker_callback(message)
+                let tag = message.data[0];
+                let data = new Uint8Array(message.data[1]);
+
+                // @ts-ignore TODO singlethreaded_main_entry may not be defined
+                maplibre.singlethreaded_main_entry(ptr, tag, data)
             }
 
             return worker;
         })
 
-        // MAJOR FIXME: cloning is not possible let clonedMap = maplibre.clone_map(init_result)
-
-        /*callbacks.worker_callback = (message) => {
-            let tag = message.data[0];
-            let data = new Uint8Array(message.data[1]);
-
-            // @ts-ignore TODO unsync_main_entry may not be defined
-            maplibre.singlethreaded_main_entry(clonedMap, tag, data)
-        }*/
-
         maplibre.run(init_result)
     }
 }
diff --git a/web/src/platform/multithreaded/pool_scheduler.rs b/web/src/platform/multithreaded/pool_scheduler.rs
index 6f68c571..25eb8331 100644
--- a/web/src/platform/multithreaded/pool_scheduler.rs
+++ b/web/src/platform/multithreaded/pool_scheduler.rs
@@ -6,6 +6,7 @@ use wasm_bindgen::{prelude::*, JsCast};
 use web_sys::Worker;
 
 use super::pool::WorkerPool;
+use crate::CurrentEnvironment;
 
 pub struct WebWorkerPoolScheduler {
     pool: WorkerPool,
diff --git a/web/src/platform/singlethreaded/apc.rs b/web/src/platform/singlethreaded/apc.rs
index 960dd400..b167689f 100644
--- a/web/src/platform/singlethreaded/apc.rs
+++ b/web/src/platform/singlethreaded/apc.rs
@@ -16,6 +16,7 @@ use std::{
 };
 
 use js_sys::Uint8Array;
+use log::info;
 use maplibre::{
     environment::Environment,
     error::Error,
@@ -25,21 +26,23 @@ use maplibre::{
         source_client::{HttpClient, HttpSourceClient, SourceClient},
         transferables::Transferables,
     },
+    kernel::Kernel,
 };
 use wasm_bindgen::{prelude::*, JsCast, JsValue};
-use web_sys::{DedicatedWorkerGlobalScope, Worker};
+use web_sys::{console::info, DedicatedWorkerGlobalScope, Worker};
 
 use crate::{
     platform::singlethreaded::transferables::{
         InnerData, LinearTessellatedLayer, LinearTransferables,
     },
-    MapType, WHATWGFetchHttpClient,
+    CurrentEnvironment, MapType, WHATWGFetchHttpClient,
 };
 
 type UsedTransferables = LinearTransferables;
 type UsedHttpClient = WHATWGFetchHttpClient;
 type UsedContext = PassingContext;
 
+#[derive(Debug)]
 enum SerializedMessageTag {
     TileTessellated = 1,
     UnavailableLayer = 2,
@@ -144,18 +147,26 @@ impl Context<UsedTransferables, UsedHttpClient> for PassingContext {
     }
 }
 
+type ReceivedType = RefCell<Vec<Message<UsedTransferables>>>;
+
 pub struct PassingAsyncProcedureCall {
     new_worker: Box<dyn Fn() -> Worker>,
     workers: Vec<Worker>,
 
-    received: RefCell<Vec<Message<UsedTransferables>>>, // FIXME (wasm-executor): Is RefCell fine?
+    received: Rc<ReceivedType>, // FIXME (wasm-executor): Is RefCell fine?
 }
 
 impl PassingAsyncProcedureCall {
     pub fn new(new_worker: js_sys::Function, initial_workers: u8) -> Self {
+        let received = Rc::new(RefCell::new(vec![]));
+        let received_ref = received.clone();
+
         let create_new_worker = Box::new(move || {
             new_worker
-                .call0(&JsValue::undefined())
+                .call1(
+                    &JsValue::undefined(),
+                    &JsValue::from(Rc::into_raw(received_ref.clone()) as u32),
+                )
                 .unwrap() // FIXME (wasm-executor): Remove unwrap
                 .dyn_into::<Worker>()
                 .unwrap() // FIXME (wasm-executor): Remove unwrap
@@ -175,7 +186,7 @@ impl PassingAsyncProcedureCall {
         Self {
             new_worker: create_new_worker,
             workers,
-            received: RefCell::new(vec![]),
+            received,
         }
     }
 }
@@ -219,25 +230,24 @@ pub async fn singlethreaded_worker_entry(procedure_ptr: u32, input: String) -> R
 /// Entry point invoked by the main thread.
 #[wasm_bindgen]
 pub unsafe fn singlethreaded_main_entry(
-    map_ptr: *const RefCell<MapType>,
+    received_ptr: *const ReceivedType,
     type_id: u32,
     data: Uint8Array,
 ) -> Result<(), JsValue> {
     // FIXME (wasm-executor): Can we make this call safe? check if it was cloned before?
-    let mut map = Rc::from_raw(map_ptr);
+    let mut received: Rc<ReceivedType> = Rc::from_raw(received_ptr);
 
     let message = Message::<UsedTransferables>::deserialize(
         SerializedMessageTag::from_u32(type_id).unwrap(),
         data,
     );
 
-    let map = map.deref().borrow();
-    let kernel = map.kernel();
+    info!("singlethreaded_main_entry {:?}", message.tag());
 
     // MAJOR FIXME: Fix mutability
-    // kernel.apc().received.push(message);
+    received.borrow_mut().push(message);
 
-    mem::forget(map); // FIXME (wasm-executor): Enforce this somehow
+    mem::forget(received); // FIXME (wasm-executor): Enforce this somehow
 
     Ok(())
 }
diff --git a/web/src/platform/singlethreaded/transferables.rs b/web/src/platform/singlethreaded/transferables.rs
index dc5105f7..067b47d4 100644
--- a/web/src/platform/singlethreaded/transferables.rs
+++ b/web/src/platform/singlethreaded/transferables.rs
@@ -1,5 +1,6 @@
 use bytemuck::{TransparentWrapper, Zeroable};
 use bytemuck_derive::{Pod, Zeroable};
+use log::warn;
 use maplibre::{
     benchmarking::tessellation::{IndexDataType, OverAlignedVertexBuffer},
     coords::WorldTileCoords,
@@ -122,6 +123,75 @@ impl TessellatedLayer for LinearTessellatedLayer {
             feature_indices_len: feature_indices.len(),
         });
 
+        if buffer.buffer.vertices.len() > 15000 {
+            warn!("vertices too large");
+            return Self {
+                data: Box::new(InnerData {
+                    coords: WrapperWorldTileCoords::wrap(coords),
+
+                    layer_name: [0; 32],
+                    layer_name_len: 0,
+
+                    vertices: LongVertexShader::wrap([ShaderVertex::zeroed(); 15000]),
+                    vertices_len: 0,
+
+                    indices: LongIndices::wrap([IndexDataType::zeroed(); 40000]),
+                    indices_len: 0,
+
+                    usable_indices: 0,
+
+                    feature_indices: [0u32; 2048],
+                    feature_indices_len: 0,
+                }),
+            };
+        }
+
+        if buffer.buffer.indices.len() > 40000 {
+            warn!("indices too large");
+            return Self {
+                data: Box::new(InnerData {
+                    coords: WrapperWorldTileCoords::wrap(coords),
+
+                    layer_name: [0; 32],
+                    layer_name_len: 0,
+
+                    vertices: LongVertexShader::wrap([ShaderVertex::zeroed(); 15000]),
+                    vertices_len: 0,
+
+                    indices: LongIndices::wrap([IndexDataType::zeroed(); 40000]),
+                    indices_len: 0,
+
+                    usable_indices: 0,
+
+                    feature_indices: [0u32; 2048],
+                    feature_indices_len: 0,
+                }),
+            };
+        }
+
+        if feature_indices.len() > 2048 {
+            warn!("feature_indices too large");
+            return Self {
+                data: Box::new(InnerData {
+                    coords: WrapperWorldTileCoords::wrap(coords),
+
+                    layer_name: [0; 32],
+                    layer_name_len: 0,
+
+                    vertices: LongVertexShader::wrap([ShaderVertex::zeroed(); 15000]),
+                    vertices_len: 0,
+
+                    indices: LongIndices::wrap([IndexDataType::zeroed(); 40000]),
+                    indices_len: 0,
+
+                    usable_indices: 0,
+
+                    feature_indices: [0u32; 2048],
+                    feature_indices_len: 0,
+                }),
+            };
+        }
+
         data.vertices.0[0..buffer.buffer.vertices.len()].clone_from_slice(&buffer.buffer.vertices);
         data.indices.0[0..buffer.buffer.indices.len()].clone_from_slice(&buffer.buffer.indices);
         data.feature_indices[0..feature_indices.len()].clone_from_slice(&feature_indices);

From ffe0005f0f47df4e436e8c3794b13b4cb55cb1e7 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Tue, 1 Nov 2022 19:53:09 +0100
Subject: [PATCH 18/31] Fix compilation

---
 maplibre-winit/src/noweb.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/maplibre-winit/src/noweb.rs b/maplibre-winit/src/noweb.rs
index 8026a051..e72932a3 100644
--- a/maplibre-winit/src/noweb.rs
+++ b/maplibre-winit/src/noweb.rs
@@ -7,7 +7,6 @@ use std::marker::PhantomData;
 
 use maplibre::{
     event_loop::EventLoop,
-    headless::map::HeadlessMap,
     io::apc::SchedulerAsyncProcedureCall,
     kernel::{Kernel, KernelBuilder},
     map::Map,

From 91e8000526153a762ac99c85a400c9f67d9f8020 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 17:56:45 +0100
Subject: [PATCH 19/31] Fix ndk-glue version

---
 android/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/android/Cargo.toml b/android/Cargo.toml
index ddfbf88e..cffc3c84 100644
--- a/android/Cargo.toml
+++ b/android/Cargo.toml
@@ -11,7 +11,7 @@ maplibre = { path = "../maplibre" }
 maplibre-winit = { path = "../maplibre-winit", version = "0.0.1"  }
 env_logger = "0.9.0"
 log = "0.4.17"
-ndk-glue = "0.5.0" # version is required by winit
+ndk-glue = "0.7.0"  # version is required by winit
 jni = "0.19.0"
 
 [lib]

From b7b48c3327cf9a10048034d305c3152f73d18f4b Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 17:57:53 +0100
Subject: [PATCH 20/31] Update idea config for gradle project

---
 android/gradle/.idea/kotlinc.xml | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 android/gradle/.idea/kotlinc.xml

diff --git a/android/gradle/.idea/kotlinc.xml b/android/gradle/.idea/kotlinc.xml
new file mode 100644
index 00000000..7e340a77
--- /dev/null
+++ b/android/gradle/.idea/kotlinc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KotlinJpsPluginSettings">
+    <option name="version" value="1.6.21" />
+  </component>
+</project>
\ No newline at end of file

From def2e8de6e941a16f879f76d9c7293a0886e5755 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 17:58:07 +0100
Subject: [PATCH 21/31] Wrap native function

---
 .../demo/src/main/java/com/example/demo/MainActivity.kt     | 2 +-
 .../lib/src/main/java/org/maplibre_rs/MapLibreRs.java       | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/android/gradle/demo/src/main/java/com/example/demo/MainActivity.kt b/android/gradle/demo/src/main/java/com/example/demo/MainActivity.kt
index eca5d4be..5aae0a3a 100644
--- a/android/gradle/demo/src/main/java/com/example/demo/MainActivity.kt
+++ b/android/gradle/demo/src/main/java/com/example/demo/MainActivity.kt
@@ -10,6 +10,6 @@ class MainActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
-        MapLibreRs.android_main()
+        MapLibreRs.start()
     }
 }
diff --git a/android/gradle/lib/src/main/java/org/maplibre_rs/MapLibreRs.java b/android/gradle/lib/src/main/java/org/maplibre_rs/MapLibreRs.java
index 5054ab4a..a4c2be76 100644
--- a/android/gradle/lib/src/main/java/org/maplibre_rs/MapLibreRs.java
+++ b/android/gradle/lib/src/main/java/org/maplibre_rs/MapLibreRs.java
@@ -1,6 +1,12 @@
 package org.maplibre_rs;
 
+import android.os.Environment;
+
 public class MapLibreRs {
+    public static void start() {
+        android_main();
+    }
+    
     public static native void android_main();
 
     static {

From 628216e366c882db91fb0bbaa7b4fbb5fe72bc38 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 17:58:18 +0100
Subject: [PATCH 22/31] Fix compilation for android

---
 android/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/android/src/lib.rs b/android/src/lib.rs
index 5217253b..7dc44c6b 100644
--- a/android/src/lib.rs
+++ b/android/src/lib.rs
@@ -5,7 +5,6 @@ use log::Level;
 use maplibre::{
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
     render::settings::{Backends, WgpuSettings},
-    MapBuilder,
 };
 use maplibre_winit::{run_headed_map, WinitMapWindowConfig};
 

From fa7e8b019e866b0c03490060ad5f0fa27a9bd962 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 17:58:31 +0100
Subject: [PATCH 23/31] Set rust nightly version for gradle project

---
 android/gradle/lib/build.gradle | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/android/gradle/lib/build.gradle b/android/gradle/lib/build.gradle
index d3f514dd..02fb6c5b 100644
--- a/android/gradle/lib/build.gradle
+++ b/android/gradle/lib/build.gradle
@@ -35,6 +35,8 @@ cargo {
     libname = "maplibre_android"
     targetDirectory = "${module}/../target"
     profile = "debug"
+    rustupChannel = "nightly-2022-10-23"
+    
 
     features {
         defaultAnd "foo", "bar"

From 44cf74683e58b3d6e4db09fc11963c282189c21a Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 17:58:58 +0100
Subject: [PATCH 24/31] Add install and separate build commands

---
 justfile | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/justfile b/justfile
index cfba2d93..3b62f6a8 100644
--- a/justfile
+++ b/justfile
@@ -97,8 +97,16 @@ web-test FEATURES: nightly-toolchain
 #profile-bench:
 # cargo flamegraph --bench render -- --bench
 
-build-android: nightly-toolchain print-android-env
-  export RUSTUP_TOOLCHAIN=$NIGHTLY_TOOLCHAIN && cd android/gradle && ./gradlew assembleDebug
+build-android: build-android-lib build-android-demo
+
+build-android-lib: nightly-toolchain print-android-env
+  export RUSTUP_TOOLCHAIN=$NIGHTLY_TOOLCHAIN && cd android/gradle && ./gradlew :lib:assembleDebug
+
+build-android-demo: nightly-toolchain print-android-env
+  export RUSTUP_TOOLCHAIN=$NIGHTLY_TOOLCHAIN && cd android/gradle && ./gradlew :demo:assembleDebug
+
+install-android-demo: nightly-toolchain print-android-env
+  export RUSTUP_TOOLCHAIN=$NIGHTLY_TOOLCHAIN && cd android/gradle && ./gradlew :demo:installDebug
 
 test-android TARGET: nightly-toolchain print-android-env
   export RUSTUP_TOOLCHAIN=$NIGHTLY_TOOLCHAIN && cargo test -p maplibre-android --target {{TARGET}} -Z build-std=std,panic_abort

From d0cefe69de2620b65572f2ace61a5a7051114205 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 20:28:30 +0100
Subject: [PATCH 25/31] Upgrade Android plugin

---
 android/gradle/demo/build.gradle                 | 5 +++--
 android/gradle/demo/src/main/AndroidManifest.xml | 3 +--
 android/gradle/lib/build.gradle                  | 9 ++++-----
 android/gradle/lib/src/main/AndroidManifest.xml  | 2 +-
 4 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/android/gradle/demo/build.gradle b/android/gradle/demo/build.gradle
index a34c5c0f..6d1ff5cf 100644
--- a/android/gradle/demo/build.gradle
+++ b/android/gradle/demo/build.gradle
@@ -1,6 +1,6 @@
 plugins {
-    id 'com.android.application' version '7.0.4' apply true
-    id 'org.jetbrains.kotlin.android' version '1.6.21' apply true
+    id 'com.android.application' version '7.2.0' apply true
+    id 'org.jetbrains.kotlin.android' version '1.7.20' apply true
 }
 
 android {
@@ -34,6 +34,7 @@ android {
     kotlinOptions {
         jvmTarget = '1.8'
     }
+    namespace 'com.example.demo'
 }
 
 dependencies {
diff --git a/android/gradle/demo/src/main/AndroidManifest.xml b/android/gradle/demo/src/main/AndroidManifest.xml
index 02f14e99..b6033a2d 100644
--- a/android/gradle/demo/src/main/AndroidManifest.xml
+++ b/android/gradle/demo/src/main/AndroidManifest.xml
@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.example.demo">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
diff --git a/android/gradle/lib/build.gradle b/android/gradle/lib/build.gradle
index 02fb6c5b..965aa3eb 100644
--- a/android/gradle/lib/build.gradle
+++ b/android/gradle/lib/build.gradle
@@ -1,7 +1,7 @@
 plugins {
     id 'org.mozilla.rust-android-gradle.rust-android' version '0.9.3' apply true
-    id 'com.android.library' version '7.0.4' apply true
-    id 'org.jetbrains.kotlin.android' version '1.6.21' apply true
+    id 'com.android.library' version '7.2.0' apply true
+    id 'org.jetbrains.kotlin.android' version '1.7.20' apply true
 }
 
 apply plugin: 'kotlin-android'
@@ -14,9 +14,7 @@ android {
     defaultConfig {
         minSdkVersion 21
         targetSdkVersion 31
-        
-        versionCode 1
-        versionName "1.0"
+
 
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
@@ -27,6 +25,7 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
+    namespace 'org.maplibre_rs'
 }
 
 cargo {
diff --git a/android/gradle/lib/src/main/AndroidManifest.xml b/android/gradle/lib/src/main/AndroidManifest.xml
index f5e61612..5c3d3655 100644
--- a/android/gradle/lib/src/main/AndroidManifest.xml
+++ b/android/gradle/lib/src/main/AndroidManifest.xml
@@ -1,2 +1,2 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest package="org.maplibre_rs" />
+<manifest/>

From fdd09e0b1923495aab4044c6f237fa215bb107eb Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 20:44:35 +0100
Subject: [PATCH 26/31] Add the possibility to late initialize the renderer

---
 benchmarks/benches/render.rs   |   2 +-
 maplibre-demo/src/headless.rs  |   2 +-
 maplibre-winit/src/lib.rs      |  41 ++++++----
 maplibre-winit/src/noweb.rs    |  33 +++++----
 maplibre/src/error.rs          |   3 +-
 maplibre/src/event_loop.rs     |  12 +--
 maplibre/src/headless/mod.rs   |  19 +++--
 maplibre/src/map.rs            | 132 ++++++++++++++++++++++++++-------
 maplibre/src/render/builder.rs | 115 ++++++++++++++--------------
 web/src/lib.rs                 |  38 +++-------
 10 files changed, 233 insertions(+), 164 deletions(-)

diff --git a/benchmarks/benches/render.rs b/benchmarks/benches/render.rs
index b231a730..705f5ad1 100644
--- a/benchmarks/benches/render.rs
+++ b/benchmarks/benches/render.rs
@@ -18,7 +18,7 @@ use maplibre::{
     kernel::{Kernel, KernelBuilder},
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
     render::{
-        builder::{InitializedRenderer, RenderBuilder},
+        builder::{InitializedRenderer, RendererBuilder},
         settings::{RendererSettings, TextureFormat},
     },
     style::Style,
diff --git a/maplibre-demo/src/headless.rs b/maplibre-demo/src/headless.rs
index a26e7d2b..de442415 100644
--- a/maplibre-demo/src/headless.rs
+++ b/maplibre-demo/src/headless.rs
@@ -6,7 +6,7 @@ use maplibre::{
     kernel::KernelBuilder,
     platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
     render::{
-        builder::RenderBuilder,
+        builder::RendererBuilder,
         settings::{RendererSettings, TextureFormat},
     },
     style::Style,
diff --git a/maplibre-winit/src/lib.rs b/maplibre-winit/src/lib.rs
index 85306359..f2da920d 100644
--- a/maplibre-winit/src/lib.rs
+++ b/maplibre-winit/src/lib.rs
@@ -1,8 +1,9 @@
 pub mod input;
 
-use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
+use std::{cell::RefCell, fmt::Debug, marker::PhantomData, ops::Deref, rc::Rc};
 
 use instant::Instant;
+use log::info;
 use maplibre::{
     environment::Environment,
     error::Error,
@@ -14,6 +15,10 @@ use maplibre::{
         transferables::{DefaultTransferables, Transferables},
     },
     map::Map,
+    render::{
+        builder::RendererBuilder,
+        settings::{Backends, WgpuSettings},
+    },
     window::{HeadedMapWindow, MapWindowConfig},
 };
 use winit::{
@@ -69,15 +74,11 @@ pub struct WinitEventLoop<ET: 'static> {
     event_loop: RawWinitEventLoop<ET>,
 }
 
-impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
+impl<ET: 'static + PartialEq + Debug> EventLoop<ET> for WinitEventLoop<ET> {
     type EventLoopProxy = WinitEventLoopProxy<ET>;
 
-    fn run<E>(
-        mut self,
-        mut window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
-        mut map: Map<E>,
-        max_frames: Option<u64>,
-    ) where
+    fn run<E>(mut self, mut map: Map<E>, max_frames: Option<u64>)
+    where
         E: Environment,
         <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
     {
@@ -89,12 +90,16 @@ impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
         self.event_loop
             .run(move |event, window_target, control_flow| {
                 #[cfg(target_os = "android")]
-                if !map.is_initialized() && event == Event::Resumed {
+                if !map.has_renderer() && event == Event::Resumed {
                     use tokio::{runtime::Handle, task};
 
                     task::block_in_place(|| {
                         Handle::current().block_on(async {
-                            map.late_init().await;
+                            map.initialize_renderer(RendererBuilder::new()
+                                .with_wgpu_settings(WgpuSettings {
+                                    backends: Some(Backends::VULKAN),
+                                    ..WgpuSettings::default()
+                                })).await.unwrap();
                         })
                     });
                     return;
@@ -111,7 +116,7 @@ impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
                     Event::WindowEvent {
                         ref event,
                         window_id,
-                    } if window_id == window.id().into() => {
+                    } if window_id == map.window().id().into() => {
                         if !input_controller.window_input(event) {
                             match event {
                                 WindowEvent::CloseRequested
@@ -125,10 +130,14 @@ impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
                                     ..
                                 } => *control_flow = ControlFlow::Exit,
                                 WindowEvent::Resized(physical_size) => {
-                                    map.context_mut().resize(physical_size.width, physical_size.height);
+                                    if let Ok(map_context) =  map.context_mut() {
+                                        map_context.resize(physical_size.width, physical_size.height);
+                                    }
                                 }
                                 WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                                    map.context_mut().resize(new_inner_size.width, new_inner_size.height);
+                                    if let Ok(map_context) =  map.context_mut() {
+                                        map_context.resize(new_inner_size.width, new_inner_size.height);
+                                    }
                                 }
                                 _ => {}
                             }
@@ -139,7 +148,9 @@ impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
                         let dt = now - last_render_time;
                         last_render_time = now;
 
-                        input_controller.update_state(map.context_mut().world.view_state_mut(), dt);
+                        if let Ok(map_context) =  map.context_mut() {
+                            input_controller.update_state(map_context.world.view_state_mut(), dt);
+                        }
 
                         match map.run_schedule() {
                             Ok(_) => {}
@@ -170,7 +181,7 @@ impl<ET: 'static> EventLoop<ET> for WinitEventLoop<ET> {
                     Event::MainEventsCleared => {
                         // RedrawRequested will only trigger once, unless we manually
                         // request it.
-                        window.request_redraw();
+                        map.window().request_redraw();
                     }
                     _ => {}
                 }
diff --git a/maplibre-winit/src/noweb.rs b/maplibre-winit/src/noweb.rs
index e72932a3..08f58959 100644
--- a/maplibre-winit/src/noweb.rs
+++ b/maplibre-winit/src/noweb.rs
@@ -11,7 +11,10 @@ use maplibre::{
     kernel::{Kernel, KernelBuilder},
     map::Map,
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
-    render::builder::{InitializedRenderer, RenderBuilder},
+    render::{
+        builder::{InitializationResult, InitializedRenderer, RendererBuilder},
+        settings::{Backends, RendererSettings, WgpuSettings},
+    },
     style::Style,
     window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
 };
@@ -83,23 +86,21 @@ pub fn run_headed_map(cache_path: Option<String>) {
             .with_scheduler(TokioScheduler::new())
             .build();
 
-        let InitializedRenderer {
-            mut window,
-            renderer,
-        } = RenderBuilder::new()
-            .build()
-            .initialize_with(&kernel)
-            .await
-            .expect("Failed to initialize renderer")
-            .unwarp();
+        let mut map = Map::new(Style::default(), kernel).unwrap();
 
-        window
+        #[cfg(not(target_os = "android"))]
+        {
+            map.initialize_renderer(RendererBuilder::new().with_wgpu_settings(WgpuSettings {
+                backends: Some(Backends::VULKAN),
+                ..WgpuSettings::default()
+            }))
+            .await
+            .unwrap();
+        }
+
+        map.window_mut()
             .take_event_loop()
             .expect("Event loop is not available")
-            .run(
-                window,
-                Map::new(Style::default(), kernel, renderer).unwrap(),
-                None,
-            )
+            .run(map, None)
     })
 }
diff --git a/maplibre/src/error.rs b/maplibre/src/error.rs
index 7b6bedf1..3b64d41a 100644
--- a/maplibre/src/error.rs
+++ b/maplibre/src/error.rs
@@ -1,6 +1,6 @@
 //! Errors which can happen in various parts of the library.
 
-use std::{fmt, fmt::Formatter, sync::mpsc::SendError};
+use std::{borrow::Cow, fmt, fmt::Formatter, sync::mpsc::SendError};
 
 use lyon::tessellation::TessellationError;
 
@@ -14,6 +14,7 @@ pub enum Error {
     Network(String),
     Tesselation(TessellationError),
     Render(RenderError),
+    Generic(Cow<'static, str>),
 }
 
 impl<E> From<E> for Error
diff --git a/maplibre/src/event_loop.rs b/maplibre/src/event_loop.rs
index 04089c64..7b796cbc 100644
--- a/maplibre/src/event_loop.rs
+++ b/maplibre/src/event_loop.rs
@@ -15,15 +15,11 @@ pub trait EventLoopProxy<T: 'static> {
     fn send_event(&self, event: T);
 }
 
-pub trait EventLoop<T: 'static> {
-    type EventLoopProxy: EventLoopProxy<T>;
+pub trait EventLoop<ET: 'static + PartialEq> {
+    type EventLoopProxy: EventLoopProxy<ET>;
 
-    fn run<E>(
-        self,
-        window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
-        map: Map<E>,
-        max_frames: Option<u64>,
-    ) where
+    fn run<E>(self, map: Map<E>, max_frames: Option<u64>)
+    where
         E: Environment,
         <E::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow;
 
diff --git a/maplibre/src/headless/mod.rs b/maplibre/src/headless/mod.rs
index fb9ed25d..d248a68b 100644
--- a/maplibre/src/headless/mod.rs
+++ b/maplibre/src/headless/mod.rs
@@ -1,10 +1,16 @@
 use crate::{
-    headless::{environment::HeadlessEnvironment, window::HeadlessMapWindowConfig},
+    headless::{
+        environment::HeadlessEnvironment,
+        window::{HeadlessMapWindow, HeadlessMapWindowConfig},
+    },
     io::apc::SchedulerAsyncProcedureCall,
     kernel::{Kernel, KernelBuilder},
     platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
-    render::{builder::RenderBuilder, Renderer},
-    window::WindowSize,
+    render::{
+        builder::{InitializedRenderer, RendererBuilder},
+        Renderer,
+    },
+    window::{MapWindowConfig, WindowSize},
 };
 
 mod graph_node;
@@ -31,9 +37,12 @@ pub async fn create_headless_renderer(
         .with_scheduler(TokioScheduler::new())
         .build();
 
-    let renderer = RenderBuilder::new()
+    let mwc: &HeadlessMapWindowConfig = kernel.map_window_config();
+    let window: HeadlessMapWindow = mwc.create();
+
+    let renderer = RendererBuilder::new()
         .build()
-        .initialize_headless_with(&kernel)
+        .initialize_headless::<HeadlessMapWindowConfig>(&window)
         .await
         .expect("Failed to initialize renderer");
 
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index 178a6dce..15835fb9 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -6,31 +6,38 @@ use crate::{
     environment::Environment,
     error::Error,
     kernel::Kernel,
-    render::{create_default_render_graph, register_default_render_stages, Renderer},
+    render::{
+        builder::{
+            InitializationResult, InitializedRenderer, RendererBuilder, UninitializedRenderer,
+        },
+        create_default_render_graph, register_default_render_stages,
+        settings::{RendererSettings, WgpuSettings},
+        Renderer,
+    },
     schedule::{Schedule, Stage},
     stages::register_stages,
     style::Style,
+    window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowSize},
     world::World,
 };
 
+pub enum MapContextState {
+    Ready(MapContext),
+    Pending { style: Style },
+}
+
 pub struct Map<E: Environment> {
     kernel: Rc<Kernel<E>>,
     schedule: Schedule,
-    map_context: MapContext,
+    map_context: MapContextState,
+    window: <E::MapWindowConfig as MapWindowConfig>::MapWindow,
 }
 
-impl<E: Environment> Map<E> {
-    pub fn new(style: Style, kernel: Kernel<E>, renderer: Renderer) -> Result<Self, Error> {
-        let window_size = renderer.state().surface().size();
-
-        let center = style.center.unwrap_or_default();
-        let world = World::new_at(
-            window_size,
-            LatLon::new(center[0], center[1]),
-            style.zoom.map(|zoom| Zoom::new(zoom)).unwrap_or_default(),
-            cgmath::Deg::<f64>(style.pitch.unwrap_or_default()),
-        );
-
+impl<E: Environment> Map<E>
+where
+    <<E as Environment>::MapWindowConfig as MapWindowConfig>::MapWindow: HeadedMapWindow,
+{
+    pub fn new(style: Style, kernel: Kernel<E>) -> Result<Self, Error> {
         let mut schedule = Schedule::default();
 
         let graph = create_default_render_graph().unwrap(); // TODO: Remove unwrap
@@ -40,29 +47,100 @@ impl<E: Environment> Map<E> {
 
         register_stages::<E>(&mut schedule, kernel.clone());
 
-        Ok(Self {
+        let mut window = kernel.map_window_config().create();
+
+        let map = Self {
             kernel,
-            map_context: MapContext {
-                style,
-                world,
-                renderer,
-            },
+            map_context: MapContextState::Pending { style },
             schedule,
-        })
+            window,
+        };
+        Ok(map)
+    }
+
+    pub async fn initialize_renderer(
+        &mut self,
+        render_builder: RendererBuilder,
+    ) -> Result<(), Error> {
+        let result = render_builder
+            .build()
+            .initialize_renderer::<E::MapWindowConfig>(&self.window)
+            .await
+            .expect("Failed to initialize renderer");
+
+        match &mut self.map_context {
+            MapContextState::Ready(_) => Err(Error::Generic("Renderer is already set".into())),
+            MapContextState::Pending { style } => {
+                let window_size = self.window.size();
+
+                let center = style.center.unwrap_or_default();
+
+                let world = World::new_at(
+                    window_size,
+                    LatLon::new(center[0], center[1]),
+                    style.zoom.map(|zoom| Zoom::new(zoom)).unwrap_or_default(),
+                    cgmath::Deg::<f64>(style.pitch.unwrap_or_default()),
+                );
+
+                match result {
+                    InitializationResult::Initialized(InitializedRenderer { renderer, .. }) => {
+                        *&mut self.map_context = MapContextState::Ready(MapContext {
+                            world,
+                            style: std::mem::take(style),
+                            renderer,
+                        });
+                    }
+                    InitializationResult::Uninizalized(UninitializedRenderer { .. }) => {}
+                    _ => panic!("Rendering context gone"),
+                };
+                Ok(())
+            }
+        }
+    }
+
+    pub fn window_mut(&mut self) -> &mut <E::MapWindowConfig as MapWindowConfig>::MapWindow {
+        &mut self.window
+    }
+    pub fn window(&self) -> &<E::MapWindowConfig as MapWindowConfig>::MapWindow {
+        &self.window
+    }
+
+    pub fn has_renderer(&self) -> bool {
+        match &self.map_context {
+            MapContextState::Ready(_) => true,
+            MapContextState::Pending { .. } => false,
+        }
     }
 
     #[tracing::instrument(name = "update_and_redraw", skip_all)]
     pub fn run_schedule(&mut self) -> Result<(), Error> {
-        self.schedule.run(&mut self.map_context);
-        Ok(())
+        match &mut self.map_context {
+            MapContextState::Ready(map_context) => {
+                self.schedule.run(map_context);
+                Ok(())
+            }
+            MapContextState::Pending { .. } => {
+                Err(Error::Generic("Renderer is already set".into()))
+            }
+        }
     }
 
-    pub fn context(&self) -> &MapContext {
-        &self.map_context
+    pub fn context(&self) -> Result<&MapContext, Error> {
+        match &self.map_context {
+            MapContextState::Ready(map_context) => Ok(map_context),
+            MapContextState::Pending { .. } => {
+                Err(Error::Generic("Renderer is already set".into()))
+            }
+        }
     }
 
-    pub fn context_mut(&mut self) -> &mut MapContext {
-        &mut self.map_context
+    pub fn context_mut(&mut self) -> Result<&mut MapContext, Error> {
+        match &mut self.map_context {
+            MapContextState::Ready(map_context) => Ok(map_context),
+            MapContextState::Pending { .. } => {
+                Err(Error::Generic("Renderer is already set".into()))
+            }
+        }
     }
 
     pub fn kernel(&self) -> &Rc<Kernel<E>> {
diff --git a/maplibre/src/render/builder.rs b/maplibre/src/render/builder.rs
index b6383e3f..ff93b29e 100644
--- a/maplibre/src/render/builder.rs
+++ b/maplibre/src/render/builder.rs
@@ -12,18 +12,16 @@ use crate::{
     window::{HeadedMapWindow, MapWindow, MapWindowConfig},
 };
 
-pub struct RenderBuilder<MWC: MapWindowConfig> {
+pub struct RendererBuilder {
     wgpu_settings: Option<WgpuSettings>,
     renderer_settings: Option<RendererSettings>,
-    phatom_mwc: PhantomData<MWC>,
 }
 
-impl<MWC: MapWindowConfig> RenderBuilder<MWC> {
+impl RendererBuilder {
     pub fn new() -> Self {
         Self {
             wgpu_settings: None,
             renderer_settings: None,
-            phatom_mwc: Default::default(),
         }
     }
 
@@ -37,97 +35,92 @@ impl<MWC: MapWindowConfig> RenderBuilder<MWC> {
         self
     }
 
-    pub fn build(self) -> UninitializedRenderer<MWC> {
+    pub fn build(self) -> UninitializedRenderer {
         UninitializedRenderer {
-            window: None,
             wgpu_settings: self.wgpu_settings.unwrap_or_default(),
             renderer_settings: self.renderer_settings.unwrap_or_default(),
         }
     }
 }
 
-pub enum InitializationResult<MWC: MapWindowConfig> {
-    Initialized(InitializedRenderer<MWC>),
-    Uninizalized(UninitializedRenderer<MWC>),
+pub enum InitializationResult {
+    Initialized(InitializedRenderer),
+    Uninizalized(UninitializedRenderer),
+    Gone,
 }
 
-impl<MWC: MapWindowConfig> InitializationResult<MWC> {
-    pub fn unwarp(self) -> InitializedRenderer<MWC> {
+impl Default for InitializationResult {
+    fn default() -> Self {
+        Self::Gone
+    }
+}
+
+impl InitializationResult {
+    pub fn unwarp_renderer(self) -> InitializedRenderer {
         match self {
             InitializationResult::Initialized(renderer) => renderer,
             InitializationResult::Uninizalized(_) => panic!("Renderer is not initialized"),
+            InitializationResult::Gone => panic!("Initialization context is gone"),
+        }
+    }
+
+    pub fn into_option(self) -> Option<Renderer> {
+        match self {
+            InitializationResult::Initialized(InitializedRenderer { renderer, .. }) => {
+                Some(renderer)
+            }
+            InitializationResult::Uninizalized(_) => None,
+            InitializationResult::Gone => panic!("Initialization context is gone"),
         }
     }
 }
 
-pub struct UninitializedRenderer<MWC: MapWindowConfig> {
-    window: Option<MWC::MapWindow>,
-    wgpu_settings: WgpuSettings,
-    renderer_settings: RendererSettings,
+pub struct UninitializedRenderer {
+    pub wgpu_settings: WgpuSettings,
+    pub renderer_settings: RendererSettings,
 }
 
-impl<MWC: MapWindowConfig> UninitializedRenderer<MWC>
-where
-    MWC::MapWindow: MapWindow + HeadedMapWindow,
-{
+impl UninitializedRenderer {
     /// Initializes the whole rendering pipeline for the given configuration.
     /// Returns the initialized map, ready to be run.
-    async fn initialize(self, map_window_config: &MWC) -> Result<InitializationResult<MWC>, Error> {
-        let window = map_window_config.create();
-
-        #[cfg(target_os = "android")]
-        {
-            Ok(InitializationResult::Uninizalized(self))
-        }
-
-        #[cfg(not(target_os = "android"))]
-        {
-            let renderer = Renderer::initialize(
-                &window,
-                self.wgpu_settings.clone(),
-                self.renderer_settings.clone(),
-            )
-            .await?;
-            Ok(InitializationResult::Initialized(InitializedRenderer {
-                window,
-                renderer,
-            }))
-        }
-    }
-
-    pub async fn initialize_with<E>(
+    pub async fn initialize_renderer<MWC>(
         self,
-        kernel: &Kernel<E>,
-    ) -> Result<InitializationResult<MWC>, Error>
+        existing_window: &MWC::MapWindow,
+    ) -> Result<InitializationResult, Error>
     where
-        E: Environment<MapWindowConfig = MWC>,
+        MWC: MapWindowConfig,
+        <MWC as MapWindowConfig>::MapWindow: HeadedMapWindow,
     {
-        self.initialize(kernel.map_window_config()).await
+        let renderer = Renderer::initialize(
+            existing_window,
+            self.wgpu_settings.clone(),
+            self.renderer_settings.clone(),
+        )
+        .await?;
+        Ok(InitializationResult::Initialized(InitializedRenderer {
+            renderer,
+        }))
     }
 }
 
 #[cfg(feature = "headless")]
-impl<MWC: MapWindowConfig> UninitializedRenderer<MWC> {
-    async fn initialize_headless(self, map_window_config: &MWC) -> Result<Renderer, Error> {
-        let window = map_window_config.create();
-
+impl UninitializedRenderer {
+    pub(crate) async fn initialize_headless<MWC>(
+        self,
+        existing_window: &MWC::MapWindow,
+    ) -> Result<Renderer, Error>
+    where
+        MWC: MapWindowConfig,
+    {
         Ok(Renderer::initialize_headless(
-            &window,
+            existing_window,
             self.wgpu_settings.clone(),
             self.renderer_settings.clone(),
         )
         .await?)
     }
-
-    pub async fn initialize_headless_with<E>(self, kernel: &Kernel<E>) -> Result<Renderer, Error>
-    where
-        E: Environment<MapWindowConfig = MWC>,
-    {
-        self.initialize_headless(kernel.map_window_config()).await
-    }
 }
 
-pub struct InitializedRenderer<MWC: MapWindowConfig> {
-    pub window: MWC::MapWindow,
+pub struct InitializedRenderer {
     pub renderer: Renderer,
 }
diff --git a/web/src/lib.rs b/web/src/lib.rs
index 18256d6b..5cc9614a 100644
--- a/web/src/lib.rs
+++ b/web/src/lib.rs
@@ -7,8 +7,9 @@ use maplibre::{
     io::{apc::SchedulerAsyncProcedureCall, scheduler::NopScheduler},
     kernel::{Kernel, KernelBuilder},
     map::Map,
-    render::builder::{InitializedRenderer, RenderBuilder},
+    render::builder::{InitializedRenderer, RendererBuilder},
     style::Style,
+    window::MapWindowConfig,
 };
 use maplibre_winit::{WinitEnvironment, WinitMapWindowConfig};
 use wasm_bindgen::prelude::*;
@@ -66,13 +67,8 @@ type CurrentEnvironment = WinitEnvironment<
 
 pub type MapType = Map<CurrentEnvironment>;
 
-pub struct InitResult {
-    initialized: InitializedRenderer<WinitMapWindowConfig<()>>,
-    kernel: Kernel<CurrentEnvironment>,
-}
-
 #[wasm_bindgen]
-pub async fn init_maplibre(new_worker: js_sys::Function) -> u32 {
+pub async fn run_maplibre(new_worker: js_sys::Function) {
     let mut kernel_builder = KernelBuilder::new()
         .with_map_window_config(WinitMapWindowConfig::new("maplibre".to_string()))
         .with_http_client(WHATWGFetchHttpClient::new());
@@ -100,31 +96,15 @@ pub async fn init_maplibre(new_worker: js_sys::Function) -> u32 {
 
     let kernel: Kernel<WinitEnvironment<_, _, _, ()>> = kernel_builder.build();
 
-    Box::into_raw(Box::new(InitResult {
-        initialized: RenderBuilder::new()
-            .build()
-            .initialize_with(&kernel)
-            .await
-            .expect("Failed to initialize renderer")
-            .unwarp(),
-        kernel,
-    })) as u32
-}
+    let mut map: MapType = Map::new(Style::default(), kernel).unwrap();
+    map.initialize_renderer(RendererBuilder::new())
+        .await
+        .unwrap();
 
-#[wasm_bindgen]
-pub unsafe fn run(init_ptr: *mut InitResult) {
-    let mut init_result = Box::from_raw(init_ptr);
-
-    let InitializedRenderer {
-        mut window,
-        renderer,
-    } = init_result.initialized;
-    let map: MapType = Map::new(Style::default(), init_result.kernel, renderer).unwrap();
-
-    window
+    map.window_mut()
         .take_event_loop()
         .expect("Event loop is not available")
-        .run(window, map, None)
+        .run(map, None)
 }
 
 #[cfg(test)]

From 0e15635f2c39b73927a81d7a02320ff512d60904 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 20:44:47 +0100
Subject: [PATCH 27/31] Update idea files for new kotlin version

---
 android/gradle/.idea/kotlinc.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/android/gradle/.idea/kotlinc.xml b/android/gradle/.idea/kotlinc.xml
index 7e340a77..e1eea1d6 100644
--- a/android/gradle/.idea/kotlinc.xml
+++ b/android/gradle/.idea/kotlinc.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.6.21" />
+    <option name="version" value="1.7.20" />
   </component>
 </project>
\ No newline at end of file

From 40f4200f4affafc5e1a42a2d8e850de2c1cf70df Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 20:47:46 +0100
Subject: [PATCH 28/31] Adjust typescript files

---
 web/lib/src/index.ts | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/web/lib/src/index.ts b/web/lib/src/index.ts
index 220df44b..a93a0efc 100644
--- a/web/lib/src/index.ts
+++ b/web/lib/src/index.ts
@@ -31,17 +31,16 @@ export const startMapLibre = async (wasmPath: string | undefined, workerPath: st
         const memory = new WebAssembly.Memory({initial: 1024, maximum: MEMORY / PAGES, shared: true})
         await maplibre.default(wasmPath, memory)
 
-        let init_result = await maplibre.init_maplibre(() => {
+        await maplibre.run_maplibre(() => {
             return workerPath ? new Worker(workerPath, {
                 type: 'module'
             }) : MultithreadedPoolWorker();
         });
-        maplibre.run(init_result)
     } else {
         const memory = new WebAssembly.Memory({initial: 1024, shared: false})
         await maplibre.default(wasmPath, memory);
 
-        let init_result = await maplibre.init_maplibre((ptr) => {
+        await maplibre.run_maplibre((ptr) => {
             let worker: Worker = workerPath ? new Worker(workerPath, {
                 type: 'module'
             }) : PoolWorker();
@@ -55,8 +54,6 @@ export const startMapLibre = async (wasmPath: string | undefined, workerPath: st
             }
 
             return worker;
-        })
-
-        maplibre.run(init_result)
+        });
     }
 }

From 00a4753825136c655ee9283645cc712149b56c9d Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 20:48:05 +0100
Subject: [PATCH 29/31] Remove unused run configs

---
 .idea/runConfigurations/Build_Android.xml     | 20 ------------------
 .../Build_WASM__single_threaded_.xml          | 21 -------------------
 2 files changed, 41 deletions(-)
 delete mode 100644 .idea/runConfigurations/Build_Android.xml
 delete mode 100644 .idea/runConfigurations/Build_WASM__single_threaded_.xml

diff --git a/.idea/runConfigurations/Build_Android.xml b/.idea/runConfigurations/Build_Android.xml
deleted file mode 100644
index dcf1e5ce..00000000
--- a/.idea/runConfigurations/Build_Android.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build Android" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="+nightly-2022-02-26 apk build -p maplibre-android -Zbuild-std" />
-    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
-    <option name="channel" value="DEFAULT" />
-    <option name="requiredFeatures" value="true" />
-    <option name="allFeatures" value="false" />
-    <option name="emulateTerminal" value="false" />
-    <option name="withSudo" value="false" />
-    <option name="backtrace" value="SHORT" />
-    <envs>
-      <env name="ANDROID_NDK_ROOT" value="$NDK_PATH$" />
-    </envs>
-    <option name="isRedirectInput" value="false" />
-    <option name="redirectInputPath" value="" />
-    <method v="2">
-      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
-    </method>
-  </configuration>
-</component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/Build_WASM__single_threaded_.xml b/.idea/runConfigurations/Build_WASM__single_threaded_.xml
deleted file mode 100644
index a4862730..00000000
--- a/.idea/runConfigurations/Build_WASM__single_threaded_.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build WASM (single-threaded)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="build -p web --features web-webgl --lib --profile wasm-dev --target wasm32-unknown-unknown" />
-    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
-    <option name="channel" value="DEFAULT" />
-    <option name="requiredFeatures" value="true" />
-    <option name="allFeatures" value="false" />
-    <option name="emulateTerminal" value="false" />
-    <option name="withSudo" value="false" />
-    <option name="buildTarget" value="REMOTE" />
-    <option name="backtrace" value="SHORT" />
-    <envs>
-      <env name="RUSTUP_TOOLCHAIN" value="nightly-2022-07-03-x86_64-unknown-linux-gnu" />
-    </envs>
-    <option name="isRedirectInput" value="false" />
-    <option name="redirectInputPath" value="" />
-    <method v="2">
-      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
-    </method>
-  </configuration>
-</component>
\ No newline at end of file

From 2070339fb646bef5c61522efa635138168974f1c Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 20:57:52 +0100
Subject: [PATCH 30/31] Fix names and remove unsed functions

---
 maplibre/src/io/tile_repository.rs            | 64 +++++--------------
 maplibre/src/render/stages/upload_stage.rs    |  5 +-
 .../src/stages/populate_tile_store_stage.rs   |  6 +-
 maplibre/src/stages/request_stage.rs          |  2 +-
 4 files changed, 23 insertions(+), 54 deletions(-)

diff --git a/maplibre/src/io/tile_repository.rs b/maplibre/src/io/tile_repository.rs
index ac4d7e46..78e4a1f2 100644
--- a/maplibre/src/io/tile_repository.rs
+++ b/maplibre/src/io/tile_repository.rs
@@ -58,7 +58,7 @@ pub struct StoredTile {
 }
 
 impl StoredTile {
-    pub fn new(coords: WorldTileCoords) -> Self {
+    pub fn pending(coords: WorldTileCoords) -> Self {
         Self {
             coords,
             layers: vec![],
@@ -73,6 +73,14 @@ impl StoredTile {
             status: TileStatus::Success,
         }
     }
+
+    pub fn failed(coords: WorldTileCoords) -> Self {
+        Self {
+            coords,
+            layers: vec![],
+            status: TileStatus::Failed,
+        }
+    }
 }
 
 /// Stores and provides access to a quad tree of cached tiles with world tile coords.
@@ -94,10 +102,10 @@ impl TileRepository {
 
     /// Inserts a tessellated layer into the quad tree at its world tile coords.
     /// If the space is vacant, the tessellated layer is inserted into a new
-    /// [crate::io::tile_repository::CachedTile].
+    /// [crate::io::tile_repository::StoredLayer].
     /// If the space is occupied, the tessellated layer is added to the current
-    /// [crate::io::tile_repository::CachedTile].
-    pub fn put_tessellated_layer(&mut self, layer: StoredLayer) {
+    /// [crate::io::tile_repository::StoredLayer].
+    pub fn put_layer(&mut self, layer: StoredLayer) {
         if let Some(entry) = layer
             .get_coords()
             .build_quad_key()
@@ -122,7 +130,7 @@ impl TileRepository {
 
     /// Returns the list of tessellated layers at the given world tile coords. None if tile is
     /// missing from the cache.
-    pub fn iter_tessellated_layers_at(
+    pub fn iter_layers_at(
         &self,
         coords: &WorldTileCoords,
     ) -> Option<impl Iterator<Item = &StoredLayer> + '_> {
@@ -137,7 +145,7 @@ impl TileRepository {
         if let Some(entry) = coords.build_quad_key().map(|key| self.tree.entry(key)) {
             match entry {
                 btree_map::Entry::Vacant(entry) => {
-                    entry.insert(StoredTile::new(coords));
+                    entry.insert(StoredTile::pending(coords));
                 }
                 _ => {}
             }
@@ -146,14 +154,14 @@ impl TileRepository {
     }
 
     /// Checks if a layer has been fetched.
-    pub fn needs_fetching(&self, coords: &WorldTileCoords) -> bool {
+    pub fn has_tile(&self, coords: &WorldTileCoords) -> bool {
         if let Some(_) = coords.build_quad_key().and_then(|key| self.tree.get(&key)) {
             return false;
         }
         true
     }
 
-    pub fn success(&mut self, coords: &WorldTileCoords) {
+    pub fn mark_tile_succeeded(&mut self, coords: &WorldTileCoords) {
         if let Some(cached_tile) = coords
             .build_quad_key()
             .and_then(|key| self.tree.get_mut(&key))
@@ -163,7 +171,7 @@ impl TileRepository {
     }
 
     /// Checks if a layer has been fetched.
-    pub fn fail(&mut self, coords: &WorldTileCoords) {
+    pub fn mark_tile_failed(&mut self, coords: &WorldTileCoords) {
         if let Some(cached_tile) = coords
             .build_quad_key()
             .and_then(|key| self.tree.get_mut(&key))
@@ -171,42 +179,4 @@ impl TileRepository {
             cached_tile.status = TileStatus::Failed;
         }
     }
-
-    /// Removes all the cached tessellate layers that are not contained within the given
-    /// layers hashset.
-    pub fn retain_missing_layer_names(
-        &self,
-        coords: &WorldTileCoords,
-        layers: &mut HashSet<String>,
-    ) {
-        if let Some(cached_tile) = coords.build_quad_key().and_then(|key| self.tree.get(&key)) {
-            let tessellated_set: HashSet<String> = cached_tile
-                .layers
-                .iter()
-                .map(|tessellated_layer| tessellated_layer.layer_name().to_string())
-                .collect();
-
-            layers.retain(|layer| !tessellated_set.contains(layer));
-        }
-    }
-
-    /// Checks if a layer is missing from the given layers set at the given coords.
-    pub fn is_layers_missing(&self, coords: &WorldTileCoords, layers: &HashSet<String>) -> bool {
-        if let Some(cached_tile) = coords.build_quad_key().and_then(|key| self.tree.get(&key)) {
-            let tessellated_set: HashSet<&str> = cached_tile
-                .layers
-                .iter()
-                .map(|tessellated_layer| tessellated_layer.layer_name())
-                .collect();
-
-            for layer in layers {
-                if !tessellated_set.contains(layer.as_str()) {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-        true
-    }
 }
diff --git a/maplibre/src/render/stages/upload_stage.rs b/maplibre/src/render/stages/upload_stage.rs
index 116b4370..f226a39b 100644
--- a/maplibre/src/render/stages/upload_stage.rs
+++ b/maplibre/src/render/stages/upload_stage.rs
@@ -164,9 +164,8 @@ impl UploadStage {
                 let loaded_layers = buffer_pool
                     .get_loaded_layers_at(&world_coords)
                     .unwrap_or_default();
-                if let Some(available_layers) = tile_repository
-                    .iter_tessellated_layers_at(&world_coords)
-                    .map(|layers| {
+                if let Some(available_layers) =
+                    tile_repository.iter_layers_at(&world_coords).map(|layers| {
                         layers
                             .filter(|result| !loaded_layers.contains(&result.layer_name()))
                             .collect::<Vec<_>>()
diff --git a/maplibre/src/stages/populate_tile_store_stage.rs b/maplibre/src/stages/populate_tile_store_stage.rs
index 3fceaf47..6fa88313 100644
--- a/maplibre/src/stages/populate_tile_store_stage.rs
+++ b/maplibre/src/stages/populate_tile_store_stage.rs
@@ -39,7 +39,7 @@ impl<E: Environment> Stage for PopulateTileStore<E> {
             match result {
                 Message::TileTessellated(tranferred) => {
                     let coords = tranferred.coords();
-                    tile_repository.success(coords);
+                    tile_repository.mark_tile_succeeded(coords);
                     tracing::trace!("Tile at {} finished loading", coords);
                     log::warn!("Tile at {} finished loading", coords);
                 }
@@ -51,7 +51,7 @@ impl<E: Environment> Stage for PopulateTileStore<E> {
                         layer.layer_name(),
                         layer.get_coords()
                     );
-                    tile_repository.put_tessellated_layer(layer);
+                    tile_repository.put_layer(layer);
                 }
                 Message::TessellatedLayer(data) => {
                     let layer: StoredLayer = data.to_stored_layer();
@@ -65,7 +65,7 @@ impl<E: Environment> Stage for PopulateTileStore<E> {
                         layer.layer_name(),
                         layer.get_coords()
                     );
-                    tile_repository.put_tessellated_layer(layer);
+                    tile_repository.put_layer(layer);
                 }
             }
         }
diff --git a/maplibre/src/stages/request_stage.rs b/maplibre/src/stages/request_stage.rs
index 613920a9..3716bca2 100644
--- a/maplibre/src/stages/request_stage.rs
+++ b/maplibre/src/stages/request_stage.rs
@@ -156,7 +156,7 @@ impl<E: Environment> RequestStage<E> {
             return Ok(false);
         }*/
 
-        if tile_repository.needs_fetching(&coords) {
+        if tile_repository.has_tile(&coords) {
             tile_repository.create_tile(coords);
 
             tracing::info!("new tile request: {}", &coords);

From e220e1df29ffd0089aa47f4d0868736061ecb794 Mon Sep 17 00:00:00 2001
From: Maximilian Ammann <max@maxammann.org>
Date: Wed, 2 Nov 2022 21:11:39 +0100
Subject: [PATCH 31/31] Fix compilation

---
 apple/src/lib.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/apple/src/lib.rs b/apple/src/lib.rs
index a3820041..c5b41661 100644
--- a/apple/src/lib.rs
+++ b/apple/src/lib.rs
@@ -1,11 +1,9 @@
 use maplibre::{
     io::apc::SchedulerAsyncProcedureCall,
     platform::{http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler},
-    MapBuilder,
 };
 use maplibre_winit::{
     run_headed_map, WinitEnvironment, WinitEventLoop, WinitMapWindow, WinitMapWindowConfig,
-    WinitWindow,
 };
 
 #[cfg(not(any(target_os = "macos", target_os = "ios")))]