diff --git a/.idea/maplibre-rs.iml b/.idea/maplibre-rs.iml
index c67bd1d39..c33d4b0c6 100644
--- a/.idea/maplibre-rs.iml
+++ b/.idea/maplibre-rs.iml
@@ -1,21 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<module type="CPP_MODULE" version="4">
+<module type="EMPTY_MODULE" version="4">
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/examples" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/libs/mbtiles/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/maplibre-build-tools/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/maplibre-style/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/maplibre-tilejson/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/maplibre/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/maplibre/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/android/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/apple/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/benchmarks/benches" isTestSource="true" />
       <sourceFolder url="file://$MODULE_DIR$/benchmarks/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/maplibre-build-tools/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/maplibre-demo/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/maplibre-winit/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/maplibre/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/web/src" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
       <excludeFolder url="file://$MODULE_DIR$/docs/book" />
diff --git a/.idea/runConfigurations/Run_Tests.xml b/.idea/runConfigurations/Run_Tests.xml
index a1cb6da8c..8da4d9aae 100644
--- a/.idea/runConfigurations/Run_Tests.xml
+++ b/.idea/runConfigurations/Run_Tests.xml
@@ -1,15 +1,16 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run Tests" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="buildProfileId" value="test" />
     <option name="command" value="test --package maplibre" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <envs />
+    <option name="emulateTerminal" value="false" />
     <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 />
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />
     <method v="2">
diff --git a/.idea/runConfigurations/Run_demo__debug_.xml b/.idea/runConfigurations/Run_demo__debug_.xml
index 008d47370..30da9ba7f 100644
--- a/.idea/runConfigurations/Run_demo__debug_.xml
+++ b/.idea/runConfigurations/Run_demo__debug_.xml
@@ -1,9 +1,11 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run demo (debug)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="buildProfileId" value="dev" />
     <option name="command" value="run -p maplibre-demo -- headed" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <envs>
       <env name="RUST_LOG" value="maplibre=info" />
+      <env name="wgpu_core" value="warning" />
     </envs>
     <option name="emulateTerminal" value="false" />
     <option name="channel" value="DEFAULT" />
diff --git a/.idea/runConfigurations/Run_demo__debug_enable_tracing_.xml b/.idea/runConfigurations/Run_demo__debug_enable_tracing_.xml
index 11ff931fb..4aa25809f 100644
--- a/.idea/runConfigurations/Run_demo__debug_enable_tracing_.xml
+++ b/.idea/runConfigurations/Run_demo__debug_enable_tracing_.xml
@@ -2,14 +2,17 @@
   <configuration default="false" name="Run demo (debug+enable-tracing)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="command" value="run -p maplibre-demo --features trace -- headed" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <envs>
+      <env name="RUST_LOG" value="maplibre=info" />
+      <env name="wgpu_core" value="warning" />
+    </envs>
+    <option name="emulateTerminal" value="false" />
     <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 />
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />
     <method v="2">
diff --git a/.idea/runConfigurations/Run_demo__release_.xml b/.idea/runConfigurations/Run_demo__release_.xml
index d5a6478b8..3a8f59205 100644
--- a/.idea/runConfigurations/Run_demo__release_.xml
+++ b/.idea/runConfigurations/Run_demo__release_.xml
@@ -2,6 +2,10 @@
   <configuration default="false" name="Run demo (release)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="command" value="run -p maplibre-demo --release -- headed" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <envs>
+      <env name="RUST_LOG" value="maplibre=info" />
+      <env name="wgpu_core" value="warning" />
+    </envs>
     <option name="emulateTerminal" value="false" />
     <option name="channel" value="DEFAULT" />
     <option name="requiredFeatures" value="true" />
@@ -9,9 +13,6 @@
     <option name="withSudo" value="false" />
     <option name="buildTarget" value="REMOTE" />
     <option name="backtrace" value="SHORT" />
-    <envs>
-      <env name="RUST_LOG" value="maplibre=trace" />
-    </envs>
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />
     <method v="2">
diff --git a/.idea/runConfigurations/Run_demo__release_enable_tracing_.xml b/.idea/runConfigurations/Run_demo__release_enable_tracing_.xml
index 9842d2336..e72ae89bf 100644
--- a/.idea/runConfigurations/Run_demo__release_enable_tracing_.xml
+++ b/.idea/runConfigurations/Run_demo__release_enable_tracing_.xml
@@ -2,14 +2,17 @@
   <configuration default="false" name="Run demo (release+enable-tracing)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="command" value="run -p maplibre-demo --release --features trace -- headed" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <envs>
+      <env name="RUST_LOG" value="maplibre=info" />
+      <env name="wgpu_core" value="warning" />
+    </envs>
+    <option name="emulateTerminal" value="false" />
     <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 />
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />
     <method v="2">
diff --git a/Cargo.toml b/Cargo.toml
index 6d1c40597..e7385bf8b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -68,15 +68,16 @@ tokio = "1.32.0"  # Individual features are customized in each crate
 tokio-util = { version = "0.7.9", features = ["rt"] }
 tracing = "0.1.37"
 tracing-subscriber = "0.3.17"
-tracing-tracy = "0.11.1"
+tracing-tracy = "=0.10.5"
 tracing-wasm = "0.2.1"  # TODO: Low quality dependency (remove in a separate PR!)
 walkdir = "2.4.0"
 wasm-bindgen = "=0.2.92"
 wasm-bindgen-futures = "0.4"
 wasm-bindgen-test = "0.3"
 web-sys = "0.3"  # Individual features are customized in each crate
-wgpu = "22.0.0"
+wgpu = "22.1.0"
 http-cache-reqwest = "0.14.0"
+bitflags = "2.6.0"
 
 [profile.release]
 lto = true
diff --git a/benchmarks/benches/data.rs b/benchmarks/benches/data.rs
index 090c8a556..c993b5f48 100644
--- a/benchmarks/benches/data.rs
+++ b/benchmarks/benches/data.rs
@@ -5,7 +5,7 @@ use maplibre::{
     benchmarking::io::static_tile_fetcher::StaticTileFetcher,
     coords::{TileCoords, ZoomLevel},
     io::apc::{Context, IntoMessage, SendError},
-    style::source::TileAddressingScheme,
+    style::{source::TileAddressingScheme, Style},
     vector::{
         process_vector_tile, DefaultVectorTransferables, ProcessVectorContext, VectorTileRequest,
     },
@@ -42,11 +42,7 @@ fn bench_process_vector_tile(c: &mut Criterion) {
                     coords: MUNICH_COORDS
                         .into_world_tile(TileAddressingScheme::XYZ)
                         .unwrap(),
-                    layers: HashSet::from([
-                        "transportation".to_owned(),
-                        "water".to_owned(),
-                        "building".to_owned(),
-                    ]),
+                    layers: Style::default().layers.iter().cloned().collect(),
                 },
                 &mut ProcessVectorContext::<DefaultVectorTransferables, _>::new(DummyContext),
             );
diff --git a/benchmarks/benches/render.rs b/benchmarks/benches/render.rs
index 20e81819e..c4c594a7c 100644
--- a/benchmarks/benches/render.rs
+++ b/benchmarks/benches/render.rs
@@ -21,14 +21,19 @@ fn headless_render(c: &mut Criterion) {
                 Box::new(HeadlessPlugin::new(false)),
             ];
 
-            let map = HeadlessMap::new(style, renderer, kernel, plugins).unwrap();
+            let map = HeadlessMap::new(style.clone(), renderer, kernel, plugins).unwrap();
 
             let tile = map
                 .fetch_tile(WorldTileCoords::from((0, 0, ZoomLevel::default())))
                 .await
                 .expect("Failed to fetch!");
 
-            let tile = map.process_tile(tile, &["water"]).await;
+            let water_layer = style
+                .layers
+                .iter()
+                .find(|layer| layer.source_layer == Some("water".to_string()))
+                .expect("water layer must exist");
+            let tile = map.process_tile(tile, water_layer).await;
 
             (map, tile)
         });
diff --git a/data/0-255.pbf b/data/0-255.pbf
new file mode 100644
index 000000000..e263928fb
Binary files /dev/null and b/data/0-255.pbf differ
diff --git a/maplibre-build-tools/src/wgsl.rs b/maplibre-build-tools/src/wgsl.rs
index cdfde7d1b..afb82ab49 100644
--- a/maplibre-build-tools/src/wgsl.rs
+++ b/maplibre-build-tools/src/wgsl.rs
@@ -62,15 +62,16 @@ pub fn validate_project_wgsl() {
             Ok(entry) => {
                 let path = entry.path();
                 if !path.is_dir() {
+                    println!("cargo:rerun-if-changed={}", path.display().to_string());
                     match validate_wgsl(&mut validator, path) {
                         Ok(_) => {}
                         Err(err) => {
                             let path = path.strip_prefix(&root_dir).unwrap_or(path);
-                            println!(
-                                "cargo:warning={}{}",
+                            panic!(
+                                "{}{}",
                                 path.to_str().unwrap(),
                                 match err {
-                                    WgslError::ValidationErr(error) => format!(": {error:?}"),
+                                    WgslError::ValidationErr(error) => format!(": {error}"),
                                     WgslError::ParserErr { error, location } =>
                                         if let Some(SourceLocation {
                                             line_number,
@@ -82,10 +83,9 @@ pub fn validate_project_wgsl() {
                                         } else {
                                             error
                                         },
-                                    WgslError::IoErr(error) => format!(": {error:?}"),
+                                    WgslError::IoErr(error) => format!(": {error}"),
                                 }
                             );
-                            exit(1);
                         }
                     };
                 }
diff --git a/maplibre-demo/src/main.rs b/maplibre-demo/src/main.rs
index 68234ddde..1b83ccfae 100644
--- a/maplibre-demo/src/main.rs
+++ b/maplibre-demo/src/main.rs
@@ -17,6 +17,7 @@ struct Cli {
     command: Commands,
 }
 
+#[allow(dead_code)]
 fn parse_lat_long(env: &str) -> Result<LatLon, std::io::Error> {
     let split = env.split(',').collect::<Vec<_>>();
     if let (Some(latitude), Some(longitude)) = (split.first(), split.get(1)) {
diff --git a/maplibre-winit/src/input/camera_handler.rs b/maplibre-winit/src/input/camera_handler.rs
index 4b76d457c..b0899c741 100644
--- a/maplibre-winit/src/input/camera_handler.rs
+++ b/maplibre-winit/src/input/camera_handler.rs
@@ -20,7 +20,7 @@ pub struct CameraHandler {
 }
 
 impl UpdateState for CameraHandler {
-    fn update_state(&mut self, MapContext { view_state, .. }: &mut MapContext, dt: Duration) {
+    fn update_state(&mut self, MapContext { view_state, .. }: &mut MapContext, _dt: Duration) {
         if !self.is_active {
             return;
         }
diff --git a/maplibre-winit/src/lib.rs b/maplibre-winit/src/lib.rs
index 780ef88c6..0762e1887 100644
--- a/maplibre-winit/src/lib.rs
+++ b/maplibre-winit/src/lib.rs
@@ -164,7 +164,7 @@ impl<ET: 'static + PartialEq + Debug> EventLoop<ET> for WinitEventLoop<ET> {
                                         }
                                     }
                                 }
-                                WindowEvent::ScaleFactorChanged { inner_size_writer, scale_factor: new_scale_factor } => {
+                                WindowEvent::ScaleFactorChanged { inner_size_writer: _, scale_factor: new_scale_factor } => {
                                     if let Ok(map_context) =  map.context_mut() {
                                         log::info!("New scaling factor: {}", new_scale_factor);
                                         scale_factor = *new_scale_factor;
diff --git a/maplibre-winit/src/noweb.rs b/maplibre-winit/src/noweb.rs
index 339b593c9..d5aceb657 100644
--- a/maplibre-winit/src/noweb.rs
+++ b/maplibre-winit/src/noweb.rs
@@ -19,7 +19,7 @@ use maplibre::{
     style::Style,
     window::{MapWindow, MapWindowConfig, PhysicalSize, WindowCreateError},
 };
-use winit::window::WindowAttributes;
+use winit::{dpi::Size, window::WindowAttributes};
 
 use super::WinitMapWindow;
 use crate::{WinitEnvironment, WinitEventLoop};
@@ -87,7 +87,12 @@ impl<ET: 'static + Clone> MapWindowConfig for WinitMapWindowConfig<ET> {
             .map_err(|_| WindowCreateError::EventLoop)?;
 
         let window = raw_event_loop
-            .create_window(WindowAttributes::new().with_title(&self.title))
+            .create_window(
+                WindowAttributes::new()
+                    .with_title(&self.title)
+                    // TODO make window size configurable
+                    .with_inner_size(Size::Logical(winit::dpi::LogicalSize::new(800.0, 800.0))),
+            )
             .map_err(|_| WindowCreateError::Window)?;
 
         Ok(Self::MapWindow {
@@ -136,6 +141,9 @@ pub fn run_headed_map<P>(
                 Box::new(maplibre::vector::VectorPlugin::<
                     maplibre::vector::DefaultVectorTransferables,
                 >::default()),
+                Box::new(maplibre::sdf::SdfPlugin::<
+                    maplibre::vector::DefaultVectorTransferables,
+                >::default()),
                 // Box::new(maplibre::raster::RasterPlugin::<
                 //     maplibre::raster::DefaultRasterTransferables,
                 // >::default()),
diff --git a/maplibre/Cargo.toml b/maplibre/Cargo.toml
index 6c1125617..bb32a1e3d 100644
--- a/maplibre/Cargo.toml
+++ b/maplibre/Cargo.toml
@@ -88,5 +88,14 @@ smallvec.workspace = true
 png = { workspace = true, optional = true }
 image = { workspace = true, optional = true }
 
+# Text/glyphs
+prost = "0.13.1"
+
+# Symbols
+bitflags = { workspace = true }
+widestring = "1.1.0"
+guillotiere = "0.6.2"
+
 [build-dependencies]
 maplibre-build-tools = { path = "../maplibre-build-tools", version = "0.1.0" }
+prost-build = "0.13.1"
diff --git a/maplibre/build.rs b/maplibre/build.rs
index 831fd0fd2..9d52c7d50 100644
--- a/maplibre/build.rs
+++ b/maplibre/build.rs
@@ -3,6 +3,8 @@
 //! This script is built and executed just before building the package.
 //! It will validate the WGSL (WebGPU Shading Language) shaders and embed static files.
 
+use std::{fs, path::PathBuf};
+
 use maplibre_build_tools::wgsl::validate_project_wgsl;
 
 #[cfg(feature = "embed-static-tiles")]
@@ -50,9 +52,27 @@ fn embed_tiles_statically() {
     }
 }
 
+fn generate_protobuf() {
+    let proto_paths = fs::read_dir("./proto")
+        .unwrap()
+        .filter_map(|entry| {
+            let entry = entry.ok()?;
+            println!(
+                "cargo:rerun-if-changed={}",
+                entry.path().display().to_string()
+            );
+            Some(entry.path())
+        })
+        .collect::<Vec<_>>();
+
+    prost_build::compile_protos(&proto_paths, &[PathBuf::from("./proto/")]).unwrap();
+}
+
 fn main() {
     validate_project_wgsl();
 
     #[cfg(feature = "embed-static-tiles")]
     embed_tiles_statically();
+
+    generate_protobuf();
 }
diff --git a/maplibre/proto/glyphs.proto b/maplibre/proto/glyphs.proto
new file mode 100644
index 000000000..47bca66cd
--- /dev/null
+++ b/maplibre/proto/glyphs.proto
@@ -0,0 +1,34 @@
+// Protocol Version 1
+// Adapted from https://github.com/maplibre/maplibre-native/blob/2e3538c2fe9bcf2e3961971a0807c2d2c17a3f06/misc/proto/glyphs.proto#L4
+
+package glyphs;
+
+option optimize_for = LITE_RUNTIME;
+
+// Stores a glyph with metrics and optional SDF bitmap information.
+message glyph {
+    required uint32 id = 1;
+
+    // A signed distance field of the glyph with a border of 3 pixels.
+    optional bytes bitmap = 2;
+
+    // Glyph metrics.
+    required uint32 width = 3;
+    required uint32 height = 4;
+    required sint32 left = 5;
+    required sint32 top = 6;
+    required uint32 advance = 7;
+}
+
+// Stores fontstack information and a list of faces.
+message fontstack {
+    required string name = 1;
+    required string range = 2;
+    repeated glyph glyphs = 3;
+}
+
+message glyphs {
+    repeated fontstack stacks = 1;
+
+    extensions 16 to 8191;
+}
\ No newline at end of file
diff --git a/maplibre/src/benchmarking.rs b/maplibre/src/benchmarking.rs
index a1bb6cece..a5f8ebea4 100644
--- a/maplibre/src/benchmarking.rs
+++ b/maplibre/src/benchmarking.rs
@@ -7,5 +7,5 @@ pub mod io {
 
 /// Re-export of the tessellation module.
 pub mod tessellation {
-    pub use crate::tessellation::*;
+    pub use crate::vector::tessellation::*;
 }
diff --git a/maplibre/src/coords.rs b/maplibre/src/coords.rs
index f240a8703..d8a338d24 100644
--- a/maplibre/src/coords.rs
+++ b/maplibre/src/coords.rs
@@ -7,7 +7,7 @@ use std::{
 };
 
 use bytemuck_derive::{Pod, Zeroable};
-use cgmath::{AbsDiffEq, Matrix4, Point3, Vector3};
+use cgmath::{AbsDiffEq, Matrix4, Point3, Vector3, Vector4};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -21,6 +21,9 @@ use crate::{
 pub const EXTENT_UINT: u32 = 4096;
 pub const EXTENT_SINT: i32 = EXTENT_UINT as i32;
 pub const EXTENT: f64 = EXTENT_UINT as f64;
+const TOP_LEFT_EXTENT: Vector4<f64> = Vector4::new(0.0, 0.0, 0.0, 1.0);
+const BOTTOM_RIGHT_EXTENT: Vector4<f64> = Vector4::new(EXTENT, EXTENT, 0.0, 1.0);
+
 pub const TILE_SIZE: f64 = 512.0;
 pub const MAX_ZOOM: usize = 32;
 
@@ -723,24 +726,22 @@ impl Display for WorldCoords {
 
 #[cfg(test)]
 mod tests {
-    use cgmath::{Point2, Vector4};
+    use cgmath::Point2;
 
     use crate::{
         coords::{
-            Quadkey, TileCoords, ViewRegion, WorldCoords, WorldTileCoords, Zoom, ZoomLevel, EXTENT,
+            Quadkey, TileCoords, ViewRegion, WorldCoords, WorldTileCoords, Zoom, ZoomLevel,
+            BOTTOM_RIGHT_EXTENT, TOP_LEFT_EXTENT,
         },
         render::tile_view_pattern::DEFAULT_TILE_SIZE,
         style::source::TileAddressingScheme,
         util::math::Aabb2,
     };
 
-    const TOP_LEFT: Vector4<f64> = Vector4::new(0.0, 0.0, 0.0, 1.0);
-    const BOTTOM_RIGHT: Vector4<f64> = Vector4::new(EXTENT, EXTENT, 0.0, 1.0);
-
     fn to_from_world(tile: (i32, i32, ZoomLevel), zoom: Zoom) {
         let tile = WorldTileCoords::from(tile);
-        let p1 = tile.transform_for_zoom(zoom) * TOP_LEFT;
-        let p2 = tile.transform_for_zoom(zoom) * BOTTOM_RIGHT;
+        let p1 = tile.transform_for_zoom(zoom) * TOP_LEFT_EXTENT;
+        let p2 = tile.transform_for_zoom(zoom) * BOTTOM_RIGHT_EXTENT;
         println!("{p1:?}\n{p2:?}");
 
         assert_eq!(
diff --git a/maplibre/src/debug/cleanup_system.rs b/maplibre/src/debug/cleanup_system.rs
index 1aa0dcf77..900fbfa2a 100644
--- a/maplibre/src/debug/cleanup_system.rs
+++ b/maplibre/src/debug/cleanup_system.rs
@@ -1,12 +1,19 @@
-use crate::{context::MapContext, debug::TileDebugItem, render::render_phase::RenderPhase};
+use crate::{
+    context::MapContext,
+    debug::TileDebugItem,
+    render::render_phase::RenderPhase,
+    tcs::system::{SystemError, SystemResult},
+};
 
-pub fn cleanup_system(MapContext { world, .. }: &mut MapContext) {
+pub fn cleanup_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
     let Some(debug_tile_phase) = world
         .resources
         .query_mut::<&mut RenderPhase<TileDebugItem>>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     debug_tile_phase.clear();
+
+    Ok(())
 }
diff --git a/maplibre/src/debug/fps_system.rs b/maplibre/src/debug/fps_system.rs
new file mode 100644
index 000000000..290044aca
--- /dev/null
+++ b/maplibre/src/debug/fps_system.rs
@@ -0,0 +1,15 @@
+use crate::{
+    context::MapContext,
+    tcs::system::{SystemError, SystemResult},
+    util::FPSMeter,
+};
+
+pub fn fps_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
+    let Some(fps_meter) = world.resources.get_mut::<FPSMeter>() else {
+        return Err(SystemError::Dependencies);
+    };
+
+    fps_meter.update_and_print();
+
+    Ok(())
+}
diff --git a/maplibre/src/debug/mod.rs b/maplibre/src/debug/mod.rs
index b6d8eb2b3..922b1d117 100644
--- a/maplibre/src/debug/mod.rs
+++ b/maplibre/src/debug/mod.rs
@@ -2,8 +2,8 @@ use std::{ops::Deref, rc::Rc};
 
 use crate::{
     debug::{
-        cleanup_system::cleanup_system, debug_pass::DebugPassNode, queue_system::queue_system,
-        resource_system::resource_system,
+        cleanup_system::cleanup_system, debug_pass::DebugPassNode, fps_system::fps_system,
+        queue_system::queue_system, resource_system::resource_system,
     },
     environment::Environment,
     kernel::Kernel,
@@ -17,10 +17,12 @@ use crate::{
     },
     schedule::Schedule,
     tcs::world::World,
+    util::FPSMeter,
 };
 
 mod cleanup_system;
 mod debug_pass;
+mod fps_system;
 mod queue_system;
 mod render_commands;
 mod resource_system;
@@ -79,8 +81,9 @@ impl<E: Environment> Plugin<E> for DebugPlugin {
         let draw_graph = graph.get_sub_graph_mut(draw_graph::NAME).unwrap();
         draw_graph.add_node(draw_graph::node::DEBUG_PASS, DebugPassNode::new());
 
+        // FIXME: remove this dependency to translucent pass
         draw_graph
-            .add_node_edge(draw_graph::node::MAIN_PASS, draw_graph::node::DEBUG_PASS)
+            .add_node_edge("translucent_pass", draw_graph::node::DEBUG_PASS)
             .unwrap();
 
         resources.init::<RenderPhase<TileDebugItem>>();
@@ -89,5 +92,8 @@ impl<E: Environment> Plugin<E> for DebugPlugin {
         schedule.add_system_to_stage(RenderStageLabel::Prepare, resource_system);
         schedule.add_system_to_stage(RenderStageLabel::Queue, queue_system);
         schedule.add_system_to_stage(RenderStageLabel::Cleanup, cleanup_system);
+
+        resources.insert(FPSMeter::new());
+        schedule.add_system_to_stage(RenderStageLabel::Cleanup, fps_system);
     }
 }
diff --git a/maplibre/src/debug/queue_system.rs b/maplibre/src/debug/queue_system.rs
index 826f2e402..9f545f252 100644
--- a/maplibre/src/debug/queue_system.rs
+++ b/maplibre/src/debug/queue_system.rs
@@ -7,14 +7,15 @@ use crate::{
         render_phase::{DrawState, RenderPhase},
         tile_view_pattern::WgpuTileViewPattern,
     },
+    tcs::system::{SystemError, SystemResult},
 };
 
-pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
+pub fn queue_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
     let Some((Initialized(tile_view_pattern), tile_debug_phase)) = world.resources.query_mut::<(
         &mut Eventually<WgpuTileViewPattern>,
         &mut RenderPhase<TileDebugItem>,
     )>() else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     for view_tile in tile_view_pattern.iter() {
@@ -30,4 +31,6 @@ pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
             });
         });
     }
+
+    Ok(())
 }
diff --git a/maplibre/src/debug/resource_system.rs b/maplibre/src/debug/resource_system.rs
index 2de8f89af..af6993818 100644
--- a/maplibre/src/debug/resource_system.rs
+++ b/maplibre/src/debug/resource_system.rs
@@ -9,6 +9,7 @@ use crate::{
         shaders::Shader,
         RenderResources, Renderer,
     },
+    tcs::system::{SystemError, SystemResult},
 };
 
 pub fn resource_system(
@@ -23,12 +24,12 @@ pub fn resource_system(
             },
         ..
     }: &mut MapContext,
-) {
+) -> SystemResult {
     let Some(debug_pipeline) = world
         .resources
         .query_mut::<&mut Eventually<DebugPipeline>>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     debug_pipeline.initialize(|| {
@@ -49,9 +50,12 @@ pub fn resource_system(
             false,
             false,
             false,
+            false,
         )
         .describe_render_pipeline()
         .initialize(device);
         DebugPipeline(pipeline)
     });
+
+    Ok(())
 }
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index b40e207dc..2042e7059 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -14,12 +14,12 @@ use crate::{
     plugin::Plugin,
     render::{eventually::Eventually, view_state::ViewState, Renderer},
     schedule::{Schedule, Stage},
-    style::Style,
+    style::{layer::StyleLayer, Style},
     tcs::world::World,
     vector::{
-        process_vector_tile, AvailableVectorLayerData, DefaultVectorTransferables,
-        LayerTessellated, ProcessVectorContext, VectorBufferPool, VectorLayerData,
-        VectorLayersDataComponent, VectorTileRequest, VectorTransferables,
+        process_vector_tile, AvailableVectorLayerBucket, DefaultVectorTransferables,
+        LayerTessellated, ProcessVectorContext, VectorBufferPool, VectorLayerBucket,
+        VectorLayerBucketComponent, VectorTileRequest, VectorTransferables,
     },
 };
 
@@ -81,12 +81,12 @@ impl HeadlessMap {
         tiles
             .spawn_mut((0, 0, ZoomLevel::default()).into())
             .expect("unable to spawn tile")
-            .insert(VectorLayersDataComponent {
+            .insert(VectorLayerBucketComponent {
                 done: true,
                 layers: layers
                     .into_iter()
                     .map(|layer| {
-                        VectorLayerData::Available(AvailableVectorLayerData {
+                        VectorLayerBucket::AvailableLayer(AvailableVectorLayerBucket {
                             coords: layer.coords,
                             source_layer: layer.layer_data.name,
                             buffer: layer.buffer,
@@ -96,7 +96,7 @@ impl HeadlessMap {
                     .collect::<Vec<_>>(),
             });
 
-        self.schedule.run(context);
+        self.schedule.run(context).expect("schedule must not error");
 
         let resources = &mut context.world.resources;
         let tiles = &mut context.world.tiles;
@@ -126,7 +126,7 @@ impl HeadlessMap {
     pub async fn process_tile(
         &self,
         tile_data: Box<[u8]>,
-        source_layers: &[&str],
+        layer: &StyleLayer,
     ) -> Vec<Box<<DefaultVectorTransferables as VectorTransferables>::LayerTessellated>> {
         let context = HeadlessContext::default();
         let mut processor =
@@ -137,10 +137,7 @@ impl HeadlessMap {
             &tile_data,
             VectorTileRequest {
                 coords: target_coords,
-                layers: source_layers
-                    .iter()
-                    .map(|layer| layer.to_string())
-                    .collect(),
+                layers: [layer].into_iter().cloned().collect(),
             },
             &mut processor,
         )
diff --git a/maplibre/src/headless/system.rs b/maplibre/src/headless/system.rs
index 1022cec8d..45628c7fd 100644
--- a/maplibre/src/headless/system.rs
+++ b/maplibre/src/headless/system.rs
@@ -6,7 +6,7 @@ use crate::{
         resource::{BufferedTextureHead, Head},
         Renderer,
     },
-    tcs::system::System,
+    tcs::system::{System, SystemError},
 };
 
 /// Stage which writes the current contents of the GPU/CPU buffer in [`BufferedTextureHead`]
@@ -41,10 +41,10 @@ impl System for WriteSurfaceBufferSystem {
                 },
             ..
         }: &mut MapContext,
-    ) {
+    ) -> Result<(), SystemError> {
         let surface = state.surface();
         match surface.head() {
-            Head::Headed(_) => {}
+            Head::Headed(_) => Err(SystemError::Setup),
             Head::Headless(buffered_texture) => {
                 let buffered_texture: Arc<BufferedTextureHead> = buffered_texture.clone();
 
@@ -69,6 +69,7 @@ impl System for WriteSurfaceBufferSystem {
                 buffered_texture.unmap();
 
                 self.frame += 1;
+                Ok(())
             }
         }
     }
diff --git a/maplibre/src/legacy/bidi.rs b/maplibre/src/legacy/bidi.rs
new file mode 100644
index 000000000..6a4f2001b
--- /dev/null
+++ b/maplibre/src/legacy/bidi.rs
@@ -0,0 +1,71 @@
+//! Translated from the QT BIDI implementation https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/bidi.cpp
+
+use std::collections::BTreeSet;
+
+use widestring::U16String;
+
+/// maplibre/maplibre-native#4add9ea original name: Char16
+pub type Char16 = u16; // was char16_t
+
+/// maplibre/maplibre-native#4add9ea original name: applyArabicShaping
+pub fn apply_arabic_shaping(str: &U16String) -> U16String {
+    // TODO: Add real implementation
+    str.clone()
+}
+
+// StyledText pairs each code point in a string with an integer indicating
+// the styling options to use for rendering that code point
+// The data structure is intended to accomodate the reordering/interleaving
+// of formatting that can happen when BiDi rearranges inputs
+/// maplibre/maplibre-native#4add9ea original name: StyledText
+pub type StyledText = (U16String, Vec<u8>);
+
+/// maplibre/maplibre-native#4add9ea original name: BiDi
+pub struct BiDi;
+
+impl BiDi {
+    // TODO: This implementation is from the QT backend and lacks ICU support
+    /// Given text in logical ordering and a set of line break points,
+    /// return a set of lines in visual order with bidi and line breaking applied
+    /// maplibre/maplibre-native#4add9ea original name: processText
+    pub fn process_text(
+        &self,
+        input: &U16String,
+        mut line_break_points: BTreeSet<usize>, // TODO: Make sure this is no output
+    ) -> Vec<U16String> {
+        line_break_points.insert(input.len());
+
+        let mut transformed_lines = Vec::new();
+        let mut start = 0;
+        for line_break_point in line_break_points {
+            transformed_lines.push(U16String::from(&input[start..line_break_point])); // TODO verify if this is correct
+            start = line_break_point;
+        }
+
+        transformed_lines
+    }
+
+    /// Same as processText but preserves per-code-point formatting information
+    /// maplibre/maplibre-native#4add9ea original name: processStyledText
+    pub fn process_styled_text(
+        &self,
+        input: &StyledText,
+        mut line_break_points: BTreeSet<usize>, // TODO: Make sure this is no output
+    ) -> Vec<StyledText> {
+        line_break_points.insert(input.0.len());
+
+        let mut transformed_lines = Vec::new();
+        let mut start = 0;
+        for line_break_point in line_break_points {
+            if line_break_point <= input.1.len() {
+                transformed_lines.push((
+                    U16String::from(&input.0[start..line_break_point]),
+                    Vec::from(&input.1[start..line_break_point]),
+                )); // TODO verify if this is correct
+                start = line_break_point;
+            }
+        }
+
+        transformed_lines
+    }
+}
diff --git a/maplibre/src/legacy/buckets/mod.rs b/maplibre/src/legacy/buckets/mod.rs
new file mode 100644
index 000000000..a7c501bbf
--- /dev/null
+++ b/maplibre/src/legacy/buckets/mod.rs
@@ -0,0 +1 @@
+pub mod symbol_bucket;
diff --git a/maplibre/src/legacy/buckets/symbol_bucket.rs b/maplibre/src/legacy/buckets/symbol_bucket.rs
new file mode 100644
index 000000000..873ed572d
--- /dev/null
+++ b/maplibre/src/legacy/buckets/symbol_bucket.rs
@@ -0,0 +1,569 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/renderer/buckets/symbol_bucket.cpp
+
+use std::{
+    collections::{BTreeMap, BTreeSet, HashMap},
+    marker::PhantomData,
+    ops::Range,
+};
+
+use geo_types::GeometryCollection;
+
+use crate::{
+    euclid::Point2D,
+    legacy::{
+        geometry_tile_data::GeometryCoordinates,
+        glyph::WritingModeType,
+        image_atlas::ImagePositions,
+        layout::{
+            symbol_feature::SymbolGeometryTileFeature,
+            symbol_instance::SymbolInstance,
+            symbol_layout::{LayerProperties, SortKeyRange},
+        },
+        style_types::{
+            PropertyValue, SymbolLayoutProperties_PossiblyEvaluated, TextWritingModeType,
+        },
+        CanonicalTileID, TileSpace,
+    },
+    render::view_state::ViewState,
+};
+
+/// maplibre/maplibre-native#4add9ea original name: PatternDependency
+struct PatternDependency;
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolVertex
+#[derive(Clone, Debug)]
+pub struct SymbolVertex {
+    pub label_anchor: Point2D<f64, TileSpace>,
+    pub o: Point2D<f64, TileSpace>,
+    pub glyph_offset_y: f64,
+    pub tx: u16,
+    pub ty: u16,
+    pub size_data: Range<f64>,
+    pub is_sdf: bool,
+    pub pixel_offset: Point2D<f64, TileSpace>,
+    pub min_font_scale: Point2D<f64, TileSpace>,
+}
+
+impl SymbolVertex {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        label_anchor: Point2D<f64, TileSpace>,
+        o: Point2D<f64, TileSpace>,
+        glyph_offset_y: f64,
+        tx: u16,
+        ty: u16,
+        size_data: Range<f64>,
+        is_sdf: bool,
+        pixel_offset: Point2D<f64, TileSpace>,
+        min_font_scale: Point2D<f64, TileSpace>,
+    ) -> SymbolVertex {
+        Self {
+            label_anchor,
+            o,
+            glyph_offset_y,
+            tx,
+            ty,
+            size_data,
+            is_sdf,
+            pixel_offset,
+            min_font_scale,
+        }
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: DynamicVertex
+#[derive(Copy, Clone, Debug)]
+pub struct DynamicVertex {
+    anchor_point: Point2D<f64, TileSpace>,
+    label_angle: f64,
+}
+/// maplibre/maplibre-native#4add9ea original name: OpacityVertex
+#[derive(Copy, Clone, Debug)]
+pub struct OpacityVertex {
+    placed: bool,
+    opacity: f64,
+}
+
+impl DynamicVertex {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(anchor_point: Point2D<f64, TileSpace>, label_angle: f64) -> Self {
+        Self {
+            anchor_point,
+            label_angle,
+        }
+    }
+}
+
+impl OpacityVertex {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(placed: bool, opacity: f64) -> Self {
+        Self { placed, opacity }
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: VertexVector
+pub type VertexVector = Vec<SymbolVertex>;
+/// maplibre/maplibre-native#4add9ea original name: DynamicVertexVector
+pub type DynamicVertexVector = Vec<DynamicVertex>;
+/// maplibre/maplibre-native#4add9ea original name: OpacityVertexVector
+pub type OpacityVertexVector = Vec<OpacityVertex>;
+/// maplibre/maplibre-native#4add9ea original name: SymbolTextAttributes
+#[derive(Default, Clone, Debug)]
+pub struct SymbolTextAttributes;
+/// maplibre/maplibre-native#4add9ea original name: SymbolSizeBinder
+#[derive(Default, Clone, Debug)]
+pub struct SymbolSizeBinder;
+
+impl SymbolSizeBinder {
+    /// maplibre/maplibre-native#4add9ea original name: getVertexSizeData
+    pub fn get_vertex_size_data(&self, feature: &SymbolGeometryTileFeature) -> Range<f64> {
+        // TODO ConstantSymbolSizeBinder
+        0.0..0.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: FeatureSortOrder
+#[derive(Default, Clone, Debug)]
+struct FeatureSortOrder;
+/// maplibre/maplibre-native#4add9ea original name: TriangleIndexVector
+#[derive(Default, Clone, Debug)]
+pub struct TriangleIndexVector {
+    pub indices: Vec<u16>,
+}
+impl TriangleIndexVector {
+    /// maplibre/maplibre-native#4add9ea original name: push
+    pub fn push(&mut self, a: u16, b: u16, c: u16) {
+        //todo!()
+        // put them flat into the buffer .len() should return the count of indices
+        self.indices.push(a);
+        self.indices.push(b);
+        self.indices.push(c);
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: len
+    pub fn len(&self) -> usize {
+        //  todo!()
+        // put them flat into the buffer .len() should return the count of indices
+        self.indices.len()
+    }
+}
+/// maplibre/maplibre-native#4add9ea original name: UploadPass
+pub struct UploadPass;
+/// maplibre/maplibre-native#4add9ea original name: SymbolInstanceReferences
+pub struct SymbolInstanceReferences;
+/// maplibre/maplibre-native#4add9ea original name: RenderLayer
+pub struct RenderLayer;
+/// maplibre/maplibre-native#4add9ea original name: CrossTileSymbolLayerIndex
+pub struct CrossTileSymbolLayerIndex;
+/// maplibre/maplibre-native#4add9ea original name: BucketPlacementData
+pub struct BucketPlacementData;
+/// maplibre/maplibre-native#4add9ea original name: Placement
+pub struct Placement;
+/// maplibre/maplibre-native#4add9ea original name: TransformState
+pub type TransformState = ViewState;
+/// maplibre/maplibre-native#4add9ea original name: RenderTile
+pub struct RenderTile;
+
+/// maplibre/maplibre-native#4add9ea original name: Segment
+#[derive(Copy, Clone, Debug)]
+pub struct Segment<T> {
+    pub vertex_offset: usize,
+    pub index_offset: usize,
+    pub vertex_length: usize,
+    pub index_length: usize,
+
+    // One DrawScope per layer ID. This minimizes rebinding in cases where
+    // several layers share buckets but have different sets of active
+    // attributes. This can happen:
+    //   * when two layers have the same layout properties, but differing
+    //     data-driven paint properties
+    //   * when two fill layers have the same layout properties, but one
+    //     uses fill-color and the other uses fill-pattern
+    // TODO drawScopes:  BTreeMap<String, gfx::DrawScope>
+    pub sort_key: f64,
+
+    pub _phandom_data: PhantomData<T>,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PlacedSymbol
+#[derive(Default, Clone, Debug)]
+pub struct PlacedSymbol {
+    pub anchor_point: Point2D<f64, TileSpace>,
+    pub segment: usize,
+    pub lower_size: f64,
+    pub upper_size: f64,
+    pub line_offset: [f64; 2],
+    pub writing_modes: WritingModeType,
+    pub line: GeometryCoordinates,
+    pub tile_distances: Vec<f64>,
+    pub glyph_offsets: Vec<f64>,
+    pub hidden: bool,
+    pub vertex_start_index: usize,
+    /// The crossTileID is only filled/used on the foreground for variable text anchors
+    pub cross_tile_id: u32,
+    /// The placedOrientation is only used when symbol layer's property is set to
+    /// support placement for orientation variants.
+    pub placed_orientation: Option<TextWritingModeType>,
+    pub angle: f64,
+    /// Reference to placed icon, only applicable for text symbols.
+    pub placed_icon_index: Option<usize>,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PatternLayerMap
+type PatternLayerMap = HashMap<String, PatternDependency>;
+
+/// maplibre/maplibre-native#4add9ea original name: SegmentVector
+type SegmentVector<T> = Vec<Segment<T>>;
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolBucketBuffer
+#[derive(Default, Clone, Debug)]
+pub struct SymbolBucketBuffer {
+    pub shared_vertices: VertexVector,
+    pub shared_dynamic_vertices: DynamicVertexVector,
+    pub shared_opacity_vertices: OpacityVertexVector,
+
+    /// maplibre/maplibre-native#4add9ea original name: TriangleIndexVector
+    // type TriangleIndexVector = gfx::IndexVector<gfx::Triangles>,
+    pub shared_triangles: TriangleIndexVector,
+    pub triangles: TriangleIndexVector,
+    //TODO triangles: &TriangleIndexVector = *sharedTriangles,
+    pub segments: SegmentVector<SymbolTextAttributes>,
+    pub placed_symbols: Vec<PlacedSymbol>,
+    //    #if MLN_LEGACY_RENDERER
+    //            std::optional<VertexBuffer> vertexBuffer,
+    //            std::optional<DynamicVertexBuffer> dynamicVertexBuffer,
+    //            std::optional<OpacityVertexBuffer> opacityVertexBuffer,
+    //            std::optional<gfx::IndexBuffer> indexBuffer,
+    //    #endif // MLN_LEGACY_RENDERER
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PaintProperties
+#[derive(Clone, Debug)]
+pub struct PaintProperties {
+    //    iconBinders: SymbolIconProgram::Binders,
+    //    textBinders:  SymbolSDFTextProgram::Binders,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: CollisionBuffer
+//struct CollisionBuffer {
+//    Box<CollisionVertexVector> sharedVertices = std::make_shared::<CollisionVertexVector>(),
+//    CollisionVertexVector& vertices() { return *sharedVertices, }
+//    CollisionVertexVector& vertices()  { return *sharedVertices, }
+//
+//    Box<CollisionDynamicVertexVector> sharedDynamicVertices = std::make_shared::<CollisionDynamicVertexVector>(),
+//    CollisionDynamicVertexVector& dynamicVertices() { return *sharedDynamicVertices, }
+//    CollisionDynamicVertexVector& dynamicVertices()  { return *sharedDynamicVertices, }
+//
+//    SegmentVector<CollisionBoxProgram::AttributeList> segments,
+//
+//    #if MLN_LEGACY_RENDERER
+//    std::optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>> vertexBuffer,
+//    std::optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>> dynamicVertexBuffer,
+//    #endif // MLN_LEGACY_RENDERER
+//}
+
+/// maplibre/maplibre-native#4add9ea original name: CollisionBoxBuffer
+//struct CollisionBoxBuffer : public CollisionBuffer {
+/// maplibre/maplibre-native#4add9ea original name: LineIndexVector
+//    type LineIndexVector = gfx::IndexVector<gfx::Lines>,
+//    Box<LineIndexVector> sharedLines = std::make_shared::<LineIndexVector>(),
+//    LineIndexVector& lines = *sharedLines,
+//    #if MLN_LEGACY_RENDERER
+//    std::optional<gfx::IndexBuffer> indexBuffer,
+//    #endif // MLN_LEGACY_RENDERER
+//}
+/// maplibre/maplibre-native#4add9ea original name: CollisionCircleBuffer
+//struct CollisionCircleBuffer : public CollisionBuffer {
+/// maplibre/maplibre-native#4add9ea original name: TriangleIndexVector
+//    //type TriangleIndexVector = gfx::IndexVector<gfx::Triangles>,
+//    Box<TriangleIndexVector> sharedTriangles = std::make_shared::<TriangleIndexVector>(),
+//    TriangleIndexVector& triangles = *sharedTriangles,
+//    #if MLN_LEGACY_RENDERER
+//            std::optional<gfx::IndexBuffer> indexBuffer,
+//    #endif // MLN_LEGACY_RENDERER
+//}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolBucket
+#[derive(Clone, Debug)]
+pub struct SymbolBucket {
+    layout: SymbolLayoutProperties_PossiblyEvaluated,
+    bucket_leader_id: String,
+    sorted_angle: f64,
+
+    // Flags
+    // TODO what are the initial values?
+    icons_need_linear: bool,
+    sort_features_by_y: bool,
+    static_uploaded: bool,
+    placement_changes_uploaded: bool,
+    dynamic_uploaded: bool,
+    sort_uploaded: bool,
+    icons_in_text: bool,
+    // Set and used by placement.
+    pub just_reloaded: bool,
+    has_variable_placement: bool,
+    has_uninitialized_symbols: bool,
+
+    //pub symbolInstances: Vec<SymbolInstance>,
+    pub sort_key_ranges: Vec<SortKeyRange>,
+
+    pub paint_properties: HashMap<String, PaintProperties>,
+
+    pub text_size_binder: Box<SymbolSizeBinder>,
+    /// maplibre/maplibre-native#4add9ea original name: VertexVector
+    //type VertexVector = gfx::VertexVector<SymbolLayoutVertex>,
+    /// maplibre/maplibre-native#4add9ea original name: VertexBuffer
+    //type VertexBuffer = gfx::VertexBuffer<SymbolLayoutVertex>,
+    /// maplibre/maplibre-native#4add9ea original name: DynamicVertexVector
+    //type DynamicVertexVector = gfx::VertexVector<gfx::Vertex<SymbolDynamicLayoutAttributes>>,
+    /// maplibre/maplibre-native#4add9ea original name: DynamicVertexBuffer
+    //type DynamicVertexBuffer = gfx::VertexBuffer<gfx::Vertex<SymbolDynamicLayoutAttributes>>,
+    /// maplibre/maplibre-native#4add9ea original name: OpacityVertexVector
+    //type OpacityVertexVector = gfx::VertexVector<gfx::Vertex<SymbolOpacityAttributes>>,
+    /// maplibre/maplibre-native#4add9ea original name: OpacityVertexBuffer
+    //type OpacityVertexBuffer = gfx::VertexBuffer<gfx::Vertex<SymbolOpacityAttributes>>,
+    pub text: SymbolBucketBuffer,
+
+    pub icon_size_binder: Box<SymbolSizeBinder>,
+    pub icon: SymbolBucketBuffer,
+    pub sdf_icon: SymbolBucketBuffer,
+
+    /// maplibre/maplibre-native#4add9ea original name: CollisionVertexVector
+    //type CollisionVertexVector = gfx::VertexVector<gfx::Vertex<CollisionBoxLayoutAttributes>>,
+    /// maplibre/maplibre-native#4add9ea original name: CollisionDynamicVertexVector
+    //type CollisionDynamicVertexVector = gfx::VertexVector<gfx::Vertex<CollisionBoxDynamicAttributes>>,
+
+    // iconCollisionBox: Box<CollisionBoxBuffer>,
+    // textCollisionBox:   Box<CollisionBoxBuffer>,
+    // iconCollisionCircle:  Box<CollisionCircleBuffer>,
+    // textCollisionCircle: Box<CollisionCircleBuffer> ,
+    tile_pixel_ratio: f64,
+    bucket_instance_id: u32,
+    allow_vertical_placement: bool,
+    placement_modes: Vec<TextWritingModeType>,
+    has_format_section_overrides: Option<bool>,
+
+    feature_sort_order: FeatureSortOrder,
+
+    uploaded: bool,
+}
+
+static MAX_BUCKET_INSTANCE_ID: u32 = 0;
+
+impl SymbolBucket {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        layout_: SymbolLayoutProperties_PossiblyEvaluated,
+        paint_properties: &BTreeMap<String, LayerProperties>,
+        text_size: &PropertyValue<f64>,
+        icon_size: &PropertyValue<f64>,
+        zoom: f64,
+        icons_need_linear: bool,
+        sort_features_by_y: bool,
+        bucket_name: String,
+        symbol_instances: Vec<SymbolInstance>,
+        sort_key_ranges: Vec<SortKeyRange>,
+        tile_pixel_ratio: f64,
+        allow_vertical_placement: bool,
+        placement_modes: Vec<TextWritingModeType>,
+        icons_in_text: bool,
+    ) -> Self {
+        // TODO MAX_BUCKET_INSTANCE_ID += 1;
+
+        // TODO
+        // for pair in paintProperties_ {
+        //      let evaluated = getEvaluated::<SymbolLayerProperties>(pair.second);
+        //     self_.paintProperties.emplace(
+        //         std::piecewise_ruct,
+        //         std::forward_as_tuple(pair.first),
+        //         std::forward_as_tuple(PaintProperties{{RenderSymbolLayer::iconPaintProperties(evaluated), zoom},
+        //                                               {RenderSymbolLayer::textPaintProperties(evaluated), zoom}}));
+        // }
+        Self {
+            layout: layout_,
+            bucket_leader_id: bucket_name,
+            sorted_angle: f64::MAX,
+            icons_need_linear: icons_need_linear
+                || icon_size.is_data_driven()
+                || !icon_size.is_zoomant(),
+            sort_features_by_y,
+            static_uploaded: false,
+            placement_changes_uploaded: false,
+            dynamic_uploaded: false,
+            sort_uploaded: false,
+            icons_in_text: false,
+            just_reloaded: false,
+            has_variable_placement: false,
+            has_uninitialized_symbols: false,
+            // TODO symbolInstances: symbolInstances_,
+            sort_key_ranges,
+            paint_properties: Default::default(),
+            text_size_binder: Default::default(),
+            // TODO textSizeBinder: SymbolSizeBinder::create(zoom, textSize, TextSize::defaultValue()),
+            text: SymbolBucketBuffer::default(),
+            icon_size_binder: Default::default(),
+            // TODO iconSizeBinder: SymbolSizeBinder::create(zoom, iconSize, IconSize::defaultValue()),
+            icon: SymbolBucketBuffer::default(),
+            sdf_icon: SymbolBucketBuffer::default(),
+            tile_pixel_ratio,
+            bucket_instance_id: MAX_BUCKET_INSTANCE_ID,
+            allow_vertical_placement,
+            placement_modes,
+            has_format_section_overrides: None,
+            feature_sort_order: FeatureSortOrder,
+            uploaded: false,
+        }
+    }
+
+    // As long as this bucket has a Prepare render pass, this function is
+    // getting called. Typically, this only happens once when the bucket is
+    // being rendered for the first time.
+    /// maplibre/maplibre-native#4add9ea original name: upload
+    pub fn upload(&self, pass: &UploadPass) {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasData
+    pub fn has_data(&self) -> bool {
+        // todo!()
+        true
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: hasTextData
+    pub fn has_text_data(&self) -> bool {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: has_icon_data
+    pub fn has_icon_data(&self) -> bool {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasSdfIconData
+    pub fn has_sdf_icon_data(&self) -> bool {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasIconCollisionBoxData
+    pub fn has_icon_collision_box_data(&self) -> bool {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasIconCollisionCircleData
+    pub fn has_icon_collision_circle_data(&self) -> bool {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasTextCollisionBoxData
+    pub fn has_text_collision_box_data(&self) -> bool {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasTextCollisionCircleData
+    pub fn has_text_collision_circle_data(&self) -> bool {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasFormatSectionOverrides
+    pub fn has_format_section_overrides(&self) -> bool {
+        //  todo!()
+        false
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: sortFeatures
+    pub fn sort_features(&self, angle: f64) {
+        todo!()
+    }
+    // Returns references to the `symbolInstances` items, sorted by viewport Y.
+    /// maplibre/maplibre-native#4add9ea original name: getSortedSymbols
+    pub fn get_sorted_symbols(&self, angle: f64) -> SymbolInstanceReferences {
+        todo!()
+    }
+    // Returns references to the `symbolInstances` items, which belong to the
+    // `sortKeyRange` range, returns references to all the symbols if
+    // |sortKeyRange| is `std::nullopt`.
+    /// maplibre/maplibre-native#4add9ea original name: getSymbols
+    pub fn get_symbols(&self, sort_key_range: &Option<SortKeyRange>) -> SymbolInstanceReferences {
+        todo!()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getOrCreateIconCollisionBox
+    //    pub fn getOrCreateIconCollisionBox(&self,) -> &CollisionBoxBuffer{
+    //        if (!self.iconCollisionBox) {
+    //            self.iconCollisionBox = std::make_unique<CollisionBoxBuffer>()
+    //        }
+    //        return *self.iconCollisionBox
+    //    }
+    /// maplibre/maplibre-native#4add9ea original name: getOrCreateTextCollisionBox
+    //    pub fn getOrCreateTextCollisionBox(&self,) -> &CollisionBoxBuffer{
+    //        if (!self.textCollisionBox) {
+    //            self.textCollisionBox = std::make_unique<CollisionBoxBuffer>()
+    //        }
+    //        return *self.textCollisionBox
+    //    }
+    /// maplibre/maplibre-native#4add9ea original name:    getOrCreateIconCollisionCircleBuffer
+    //    pub fn    getOrCreateIconCollisionCircleBuffer(&self,)  -> &CollisionCircleBuffer{
+    //        if (!self.iconCollisionCircle) {
+    //            self.iconCollisionCircle = std::make_unique<CollisionCircleBuffer>()
+    //        }
+    //        return *self.iconCollisionCircle
+    //    }
+    /// maplibre/maplibre-native#4add9ea original name:  getOrCreateTextCollisionCircleBuffer
+    //    pub fn  getOrCreateTextCollisionCircleBuffer(&self,) -> &CollisionCircleBuffer {
+    //        if (!self.textCollisionCircle) {
+    //            self.textCollisionCircle = std::make_unique<CollisionCircleBuffer>(),
+    //        }
+    //        return *self.textCollisionCircle
+    //    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getQueryRadius
+    pub fn get_query_radius(&self, layer: RenderLayer) -> f64 {
+        0.
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: needsUpload
+    pub fn needs_upload(&self) -> bool {
+        self.has_data() && !self.uploaded
+    }
+
+    // Feature geometries are also used to populate the feature index.
+    // Obtaining these is a costly operation, so we do it only once, and
+    // pass-by--ref the geometries as a second parameter.
+    /// maplibre/maplibre-native#4add9ea original name: addFeature
+    pub fn add_feature(
+        &self,
+        geometry_tile_fature: &SymbolGeometryTileFeature,
+        geometry_collection: &GeometryCollection,
+        image_positions: &ImagePositions,
+        patter_layer_map: &PatternLayerMap,
+        value: usize,
+        canonical: &CanonicalTileID,
+    ) {
+    }
+
+    // The following methods are implemented by buckets that require cross-tile indexing and placement.
+
+    // Returns a pair, the first element of which is a bucket cross-tile id
+    // on success call, `0` otherwise. The second element is `true` if
+    // the bucket was originally registered, `false` otherwise.
+    /// maplibre/maplibre-native#4add9ea original name: registerAtCrossTileIndex
+    pub fn register_at_cross_tile_index(
+        &self,
+        cross_tile_index: &CrossTileSymbolLayerIndex,
+        render_tile: &RenderTile,
+    ) -> (u32, bool) {
+        todo!()
+    }
+    // Places this bucket to the given placement.
+    /// maplibre/maplibre-native#4add9ea original name: place
+    pub fn place(
+        &self,
+        placement: &Placement,
+        bucket_placement_data: &BucketPlacementData,
+        values: &BTreeSet<u32>,
+    ) {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: updateVertices
+    pub fn update_vertices(
+        placement: &Placement,
+        update_opacities: bool,
+        transform_state: &TransformState,
+        render_tile: &RenderTile,
+        values: &BTreeSet<u32>,
+    ) {
+        todo!()
+    }
+}
diff --git a/maplibre/src/legacy/collision_feature.rs b/maplibre/src/legacy/collision_feature.rs
new file mode 100644
index 000000000..fb787c2b5
--- /dev/null
+++ b/maplibre/src/legacy/collision_feature.rs
@@ -0,0 +1,398 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/text/collision_feature.cpp
+
+use crate::{
+    euclid::{Box2D, Point2D, Vector2D},
+    legacy::{
+        geometry::{anchor::Anchor, feature_index::IndexedSubfeature},
+        geometry_tile_data::{GeometryCoordinate, GeometryCoordinates},
+        glyph::Shaping,
+        grid_index::Circle,
+        shaping::{Padding, PositionedIcon},
+        style_types::SymbolPlacementType,
+        util::math::{convert_point_f64, convert_point_i16, deg2radf, rotate, MinMax},
+        ScreenSpace, TileSpace,
+    },
+};
+
+/// maplibre/maplibre-native#4add9ea original name: CollisionFeature
+#[derive(Clone)]
+pub struct CollisionFeature {
+    pub boxes: Vec<CollisionBox>,
+    pub indexed_feature: IndexedSubfeature,
+    pub along_line: bool,
+}
+
+impl CollisionFeature {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        line: &GeometryCoordinates,
+        anchor: &Anchor,
+        top: f64,
+        bottom: f64,
+        left: f64,
+        right: f64,
+        collision_padding: Option<Padding>,
+        box_scale: f64,
+        padding: f64,
+        placement: SymbolPlacementType,
+        indexed_feature: IndexedSubfeature,
+        overscaling: f64,
+        rotate_: f64,
+    ) -> Self {
+        let mut self_ = Self {
+            boxes: vec![],
+            indexed_feature,
+            along_line: placement != SymbolPlacementType::Point,
+        };
+
+        if top == 0. && bottom == 0. && left == 0. && right == 0. {
+            return self_;
+        }
+
+        let mut y1 = top * box_scale - padding;
+        let mut y2 = bottom * box_scale + padding;
+        let mut x1 = left * box_scale - padding;
+        let mut x2 = right * box_scale + padding;
+
+        if let Some(collision_padding) = collision_padding {
+            x1 -= collision_padding.left * box_scale;
+            y1 -= collision_padding.top * box_scale;
+            x2 += collision_padding.right * box_scale;
+            y2 += collision_padding.bottom * box_scale;
+        }
+
+        if self_.along_line {
+            let mut height = y2 - y1;
+            let length = x2 - x1;
+
+            if height <= 0.0 {
+                return self_;
+            }
+
+            height = 10.0 * box_scale.max(height);
+
+            let anchor_point = convert_point_i16(&anchor.point);
+            self_.bboxify_label(
+                line,
+                &anchor_point,
+                anchor.segment.unwrap_or(0),
+                length,
+                height,
+                overscaling,
+            );
+        } else if rotate_ != 0. {
+            // Account for *-rotate in point collision boxes
+            // Doesn't account for icon-text-fit
+            let rotate_radians = deg2radf(rotate_);
+
+            let tl = rotate(&Vector2D::<_, TileSpace>::new(x1, y1), rotate_radians);
+            let tr = rotate(&Vector2D::<_, TileSpace>::new(x2, y1), rotate_radians);
+            let bl = rotate(&Vector2D::<_, TileSpace>::new(x1, y2), rotate_radians);
+            let br = rotate(&Vector2D::<_, TileSpace>::new(x2, y2), rotate_radians);
+
+            // Collision features require an "on-axis" geometry,
+            // so take the envelope of the rotated geometry
+            // (may be quite large for wide labels rotated 45 degrees)
+            let x_min = [tl.x, tr.x, bl.x, br.x].min_value();
+            let x_max = [tl.x, tr.x, bl.x, br.x].max_value();
+            let y_min = [tl.y, tr.y, bl.y, br.y].min_value();
+            let y_max = [tl.y, tr.y, bl.y, br.y].max_value();
+
+            self_.boxes.push(CollisionBox {
+                anchor: anchor.point,
+                x1: x_min,
+                y1: y_min,
+                x2: x_max,
+                y2: y_max,
+                signed_distance_from_anchor: 0.0,
+            });
+        } else {
+            self_.boxes.push(CollisionBox {
+                anchor: anchor.point,
+                x1,
+                y1,
+                x2,
+                y2,
+                signed_distance_from_anchor: 0.0,
+            });
+        }
+        self_
+    }
+
+    // for text
+    /// maplibre/maplibre-native#4add9ea original name: new_from_text
+    pub fn new_from_text(
+        line: &GeometryCoordinates,
+        anchor: &Anchor,
+        shaped_text: Shaping,
+        box_scale: f64,
+        padding: f64,
+        placement: SymbolPlacementType,
+        indexed_feature: IndexedSubfeature,
+        overscaling: f64,
+        rotate: f64,
+    ) -> Self {
+        Self::new(
+            line,
+            anchor,
+            shaped_text.top,
+            shaped_text.bottom,
+            shaped_text.left,
+            shaped_text.right,
+            None,
+            box_scale,
+            padding,
+            placement,
+            indexed_feature,
+            overscaling,
+            rotate,
+        )
+    }
+
+    // for icons
+    // Icons collision features are always SymbolPlacementType::Point, which
+    // means the collision feature will be viewport-rotation-aligned even if the
+    // icon is map-rotation-aligned (e.g. `icon-rotation-alignment: map` _or_
+    // `symbol-placement: line`). We're relying on most icons being "close
+    // enough" to square that having incorrect rotation alignment doesn't throw
+    // off collision detection too much. See:
+    // https://github.com/mapbox/mapbox-gl-js/issues/4861
+    /// maplibre/maplibre-native#4add9ea original name: new_from_icon
+    pub fn new_from_icon(
+        line: &GeometryCoordinates,
+        anchor: &Anchor,
+        shaped_icon: &Option<PositionedIcon>,
+        box_scale: f64,
+        padding: f64,
+        indexed_feature: IndexedSubfeature,
+        rotate: f64,
+    ) -> Self {
+        Self::new(
+            line,
+            anchor,
+            if let Some(shaped_icon) = &shaped_icon {
+                shaped_icon.top
+            } else {
+                0.
+            },
+            if let Some(shaped_icon) = &shaped_icon {
+                shaped_icon.bottom
+            } else {
+                0.
+            },
+            if let Some(shaped_icon) = &shaped_icon {
+                shaped_icon.left
+            } else {
+                0.
+            },
+            if let Some(shaped_icon) = &shaped_icon {
+                shaped_icon.right
+            } else {
+                0.
+            },
+            shaped_icon
+                .as_ref()
+                .map(|shaped_icon| shaped_icon.collision_padding),
+            box_scale,
+            padding,
+            SymbolPlacementType::Point,
+            indexed_feature,
+            1.,
+            rotate,
+        )
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: bboxifyLabel
+    fn bboxify_label(
+        &mut self,
+        line: &GeometryCoordinates,
+        anchor_point: &GeometryCoordinate,
+        segment: usize,
+        label_length: f64,
+        box_size: f64,
+        overscaling: f64,
+    ) {
+        let step = box_size / 2.;
+        let n_boxes = ((label_length / step).floor() as i32).max(1);
+
+        // We calculate line collision circles out to 300% of what would normally be
+        // our max size, to allow collision detection to work on labels that expand
+        // as they move into the distance Vertically oriented labels in the distant
+        // field can extend past this padding This is a noticeable problem in
+        // overscaled tiles where the pitch 0-based symbol spacing will put labels
+        // very close together in a pitched map. To reduce the cost of adding extra
+        // collision circles, we slowly increase them for overscaled tiles.
+        let overscaling_padding_factor = 1. + 0.4 * overscaling.log2();
+        let n_pitch_padding_boxes =
+            ((n_boxes as f64 * overscaling_padding_factor / 2.).floor()) as i32;
+
+        // offset the center of the first box by half a box so that the edge of the
+        // box is at the edge of the label.
+        let first_box_offset = -box_size / 2.;
+
+        let mut p = anchor_point;
+        let mut index = segment + 1;
+        let mut anchor_distance = first_box_offset;
+        let label_start_distance = -label_length / 2.;
+        let padding_start_distance = label_start_distance - label_length / 8.;
+
+        // move backwards along the line to the first segment the label appears on
+        loop {
+            if index == 0 {
+                if anchor_distance > label_start_distance {
+                    // there isn't enough room for the label after the beginning of
+                    // the line checkMaxAngle should have already caught this
+                    return;
+                } else {
+                    // The line doesn't extend far enough back for all of our padding,
+                    // but we got far enough to show the label under most conditions.
+                    index = 0;
+                    break;
+                }
+            }
+
+            index -= 1;
+            anchor_distance -= convert_point_f64(&line[index]).distance_to(convert_point_f64(p));
+            p = &line[index];
+
+            if !(anchor_distance > padding_start_distance) {
+                break;
+            }
+        }
+
+        let mut segment_length =
+            convert_point_f64(&line[index]).distance_to(convert_point_f64(&line[index + 1]));
+
+        for i in -n_pitch_padding_boxes..n_boxes + n_pitch_padding_boxes {
+            // the distance the box will be from the anchor
+            let box_offset = i as f64 * step;
+            let mut box_distance_to_anchor = label_start_distance + box_offset;
+
+            // make the distance between pitch padding boxes bigger
+            if box_offset < 0. {
+                box_distance_to_anchor += box_offset;
+            }
+            if box_offset > label_length {
+                box_distance_to_anchor += box_offset - label_length;
+            }
+
+            if box_distance_to_anchor < anchor_distance {
+                // The line doesn't extend far enough back for this box, skip it
+                // (This could allow for line collisions on distant tiles)
+                continue;
+            }
+
+            // the box is not on the current segment. Move to the next segment.
+            while anchor_distance + segment_length < box_distance_to_anchor {
+                anchor_distance += segment_length;
+                index += 1;
+
+                // There isn't enough room before the end of the line.
+                if index + 1 >= line.len() {
+                    return;
+                }
+
+                segment_length = convert_point_f64(&line[index])
+                    .distance_to(convert_point_f64(&line[index + 1]));
+            }
+
+            // the distance the box will be from the beginning of the segment
+            let segment_box_distance = box_distance_to_anchor - anchor_distance;
+
+            let p0 = line[index];
+            let p1 = line[index + 1];
+
+            let box_anchor = Point2D::new(
+                p0.x as f64 + segment_box_distance / segment_length * (p1.x - p0.x) as f64,
+                p0.y as f64 + segment_box_distance / segment_length * (p1.y - p0.y) as f64,
+            );
+
+            // If the box is within boxSize of the anchor, force the box to be used
+            // (so even 0-width labels use at least one box)
+            // Otherwise, the .8 multiplication gives us a little bit of conservative
+            // padding in choosing which boxes to use (see CollisionIndex#placedCollisionCircles)
+            let padded_anchor_distance = if (box_distance_to_anchor - first_box_offset).abs() < step
+            {
+                0.0
+            } else {
+                (box_distance_to_anchor - first_box_offset) * 0.8
+            };
+
+            self.boxes.push(CollisionBox {
+                anchor: box_anchor,
+                x1: -box_size / 2.,
+                y1: -box_size / 2.,
+                x2: box_size / 2.,
+                y2: box_size / 2.,
+                signed_distance_from_anchor: padded_anchor_distance,
+            });
+        }
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: CollisionBox
+#[derive(Default, Clone, Copy, Debug)]
+pub struct CollisionBox {
+    // the box is centered around the anchor point
+    pub anchor: Point2D<f64, TileSpace>,
+
+    // the offset of the box from the label's anchor point.
+    // TODO: might be needed for #13526
+    // Point<f64> offset;
+
+    // distances to the edges from the anchor
+    pub x1: f64,
+    pub y1: f64,
+    pub x2: f64,
+    pub y2: f64,
+
+    pub signed_distance_from_anchor: f64,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: ProjectedCollisionBox
+#[derive(Clone, Copy, Debug)]
+pub enum ProjectedCollisionBox {
+    Circle(Circle<f64>),
+    Box(Box2D<f64, ScreenSpace>),
+}
+
+impl Default for ProjectedCollisionBox {
+    /// maplibre/maplibre-native#4add9ea original name: default
+    fn default() -> Self {
+        Self::Box(Box2D::zero())
+    }
+}
+
+impl ProjectedCollisionBox {
+    /// maplibre/maplibre-native#4add9ea original name: box_
+    pub fn box_(&self) -> &Box2D<f64, ScreenSpace> {
+        match self {
+            ProjectedCollisionBox::Circle(_) => panic!("not a box"),
+            ProjectedCollisionBox::Box(box_) => box_,
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: circle
+    pub fn circle(&self) -> &Circle<f64> {
+        match self {
+            ProjectedCollisionBox::Circle(circle) => circle,
+            ProjectedCollisionBox::Box(_) => panic!("not a circle"),
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: isBox
+    pub fn is_box(&self) -> bool {
+        match self {
+            ProjectedCollisionBox::Circle(_) => false,
+            ProjectedCollisionBox::Box(_) => true,
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: isCircle
+    pub fn is_circle(&self) -> bool {
+        match self {
+            ProjectedCollisionBox::Circle(_) => true,
+            ProjectedCollisionBox::Box(_) => false,
+        }
+    }
+}
diff --git a/maplibre/src/legacy/collision_index.rs b/maplibre/src/legacy/collision_index.rs
new file mode 100644
index 000000000..39cae41d5
--- /dev/null
+++ b/maplibre/src/legacy/collision_index.rs
@@ -0,0 +1,644 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/text/collision_index.cpp
+
+use std::collections::HashMap;
+
+use bitflags::bitflags;
+use cgmath::{Matrix4, Vector4};
+
+use crate::{
+    coords::EXTENT,
+    euclid::{Box2D, Point2D},
+    legacy::{
+        buckets::symbol_bucket::PlacedSymbol,
+        collision_feature::{CollisionBox, CollisionFeature, ProjectedCollisionBox},
+        geometry::feature_index::IndexedSubfeature,
+        grid_index::{Circle, GridIndex},
+        layout::symbol_projection::{place_first_and_last_glyph, project, TileDistance},
+        util::geo::ScreenLineString,
+        MapMode, ScreenSpace, TileSpace,
+    },
+    render::{camera::ModelViewProjection, view_state::ViewState},
+};
+
+/// maplibre/maplibre-native#4add9ea original name: TransformState
+type TransformState = ViewState;
+
+/// maplibre/maplibre-native#4add9ea original name: CollisionBoundaries
+type CollisionBoundaries = Box2D<f64, ScreenSpace>; // [f64; 4]; // [x1, y1, x2, y2]
+
+bitflags! {
+    /// Represents a set of flags.
+    /// maplibre/maplibre-native#4add9ea original name: IntersectStatusFlags:
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    struct IntersectStatusFlags: u8 {
+        const None = 0;
+        const HorizontalBorders = 1 << 0;
+        const VerticalBorders = 1 << 1;
+
+    }
+}
+
+impl Default for IntersectStatusFlags {
+    /// maplibre/maplibre-native#4add9ea original name: default
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IntersectStatus
+#[derive(Default)]
+struct IntersectStatus {
+    flags: IntersectStatusFlags,
+    // Assuming tile border divides box in two sections
+    min_section_length: i32,
+}
+
+// When a symbol crosses the edge that causes it to be included in
+// collision detection, it will cause changes in the symbols around
+// it. This ant specifies how many pixels to pad the edge of
+// the viewport for collision detection so that the bulk of the changes
+// occur offscreen. Making this ant greater increases label
+// stability, but it's expensive.
+// TODO remove const viewportPaddingDefault: f64 = -10.;
+const VIEWPORT_PADDING_DEFAULT: f64 = 100.;
+// Viewport padding must be much larger for static tiles to avoid clipped labels.
+const VIEWPORT_PADDING_FOR_STATIC_TILES: f64 = 1024.;
+
+/// maplibre/maplibre-native#4add9ea original name: findViewportPadding
+fn find_viewport_padding(transform_state: &TransformState, map_mode: MapMode) -> f64 {
+    if map_mode == MapMode::Tile {
+        return VIEWPORT_PADDING_FOR_STATIC_TILES;
+    }
+    if transform_state.camera().get_pitch().0 != 0.0 {
+        VIEWPORT_PADDING_DEFAULT * 2.
+    } else {
+        VIEWPORT_PADDING_DEFAULT
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: CollisionGrid
+type CollisionGrid = GridIndex<IndexedSubfeature>;
+/// maplibre/maplibre-native#4add9ea original name: CollisionIndex
+pub struct CollisionIndex {
+    transform_state: TransformState,
+    viewport_padding: f64,
+    collision_grid: CollisionGrid,
+    ignored_grid: CollisionGrid,
+    screen_right_boundary: f64,
+    screen_bottom_boundary: f64,
+    grid_right_boundary: f64,
+    grid_bottom_boundary: f64,
+    pitch_factor: f64,
+}
+
+impl CollisionIndex {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(transform_state: &TransformState, map_mode: MapMode) -> Self {
+        let viewport_padding = find_viewport_padding(transform_state, map_mode);
+        Self {
+            transform_state: transform_state.clone(),
+            viewport_padding,
+            collision_grid: CollisionGrid::new(
+                transform_state.width() + 2. * viewport_padding,
+                transform_state.height() + 2. * viewport_padding,
+                25,
+            ),
+            ignored_grid: CollisionGrid::new(
+                transform_state.width() + 2. * viewport_padding,
+                transform_state.height() + 2. * viewport_padding,
+                25,
+            ),
+            screen_right_boundary: transform_state.width() + viewport_padding,
+            screen_bottom_boundary: transform_state.height() + viewport_padding,
+            grid_right_boundary: transform_state.width() + 2. * viewport_padding,
+            grid_bottom_boundary: transform_state.height() + 2. * viewport_padding,
+            pitch_factor: transform_state.camera().get_pitch().0.cos()
+                * transform_state.camera_to_center_distance(),
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: intersectsTileEdges
+    pub fn intersects_tile_edges(
+        &self,
+        box_: &CollisionBox,
+        shift: Point2D<f64, ScreenSpace>,
+        pos_matrix: &ModelViewProjection,
+        text_pixel_ratio: f64,
+        tile_edges: CollisionBoundaries,
+    ) -> IntersectStatus {
+        let boundaries =
+            self.get_projected_collision_boundaries(pos_matrix, shift, text_pixel_ratio, box_);
+        let mut result: IntersectStatus = IntersectStatus::default();
+        let x1 = boundaries.min.x;
+        let y1 = boundaries.min.y;
+        let x2 = boundaries.max.x;
+        let y2 = boundaries.max.y;
+
+        let tile_x1 = tile_edges.min.x;
+        let tile_y1 = tile_edges.min.y;
+        let tile_x2 = tile_edges.max.x;
+        let tile_y2 = tile_edges.max.y;
+
+        // Check left border
+        let mut min_section_length = ((tile_x1 - x1).min(x2 - tile_x1)) as i32;
+        if min_section_length <= 0 {
+            // Check right border
+            min_section_length = ((tile_x2 - x1).min(x2 - tile_x2)) as i32;
+        }
+        if min_section_length > 0 {
+            result.flags |= IntersectStatusFlags::VerticalBorders;
+            result.min_section_length = min_section_length;
+        }
+        // Check top border
+        min_section_length = ((tile_y1 - y1).min(y2 - tile_y1)) as i32;
+        if min_section_length <= 0 {
+            // Check bottom border
+            min_section_length = ((tile_y2 - y1).min(y2 - tile_y2)) as i32;
+        }
+        if min_section_length > 0 {
+            result.flags |= IntersectStatusFlags::HorizontalBorders;
+            result.min_section_length = (result.min_section_length).min(min_section_length);
+        }
+        result
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: placeFeature
+    pub fn place_feature<F>(
+        &self,
+        feature: &CollisionFeature,
+        shift: Point2D<f64, ScreenSpace>,
+        pos_matrix: &ModelViewProjection,
+        label_plane_matrix: &Matrix4<f64>,
+        text_pixel_ratio: f64,
+        symbol: &PlacedSymbol,
+        scale: f64,
+        font_size: f64,
+        allow_overlap: bool,
+        pitch_with_map: bool,
+        collision_debug: bool,
+        avoid_edges: Option<CollisionBoundaries>,
+        collision_group_predicate: Option<F>,
+        projected_boxes: &mut Vec<ProjectedCollisionBox>, /*out*/
+    ) -> (bool, bool)
+    where
+        F: Fn(&IndexedSubfeature) -> bool,
+    {
+        assert!(projected_boxes.is_empty());
+        if !feature.along_line {
+            let box_ = feature.boxes.first().unwrap();
+            let collision_boundaries =
+                self.get_projected_collision_boundaries(pos_matrix, shift, text_pixel_ratio, box_);
+            projected_boxes.push(ProjectedCollisionBox::Box(collision_boundaries));
+
+            if let Some(avoid_edges) = avoid_edges {
+                if !self.is_inside_tile(&collision_boundaries, &avoid_edges) {
+                    return (false, false);
+                }
+            }
+
+            if !self.is_inside_grid(&collision_boundaries)
+                || (!allow_overlap
+                    && self.collision_grid.hit_test(
+                        projected_boxes.last().unwrap().box_(),
+                        collision_group_predicate,
+                    ))
+            {
+                return (false, false);
+            }
+
+            (true, self.is_offscreen(&collision_boundaries))
+        } else {
+            self.place_line_feature(
+                feature,
+                pos_matrix,
+                label_plane_matrix,
+                text_pixel_ratio,
+                symbol,
+                scale,
+                font_size,
+                allow_overlap,
+                pitch_with_map,
+                collision_debug,
+                avoid_edges,
+                collision_group_predicate,
+                projected_boxes,
+            )
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: insertFeature
+    pub fn insert_feature(
+        &mut self,
+        feature: CollisionFeature,
+        projected_boxes: &Vec<ProjectedCollisionBox>,
+        ignore_placement: bool,
+        bucket_instance_id: u32,
+        collision_group_id: u16,
+    ) {
+        if feature.along_line {
+            for circle in projected_boxes {
+                if !circle.is_circle() {
+                    continue;
+                }
+
+                if ignore_placement {
+                    self.ignored_grid.insert_circle(
+                        IndexedSubfeature::new(
+                            feature.indexed_feature.clone(),
+                            bucket_instance_id,
+                            collision_group_id,
+                        ), // FIXME clone() should not be needed?
+                        *circle.circle(),
+                    );
+                } else {
+                    self.collision_grid.insert_circle(
+                        IndexedSubfeature::new(
+                            feature.indexed_feature.clone(),
+                            bucket_instance_id,
+                            collision_group_id,
+                        ), // FIXME clone() should not be needed?
+                        *circle.circle(),
+                    );
+                }
+            }
+        } else if !projected_boxes.is_empty() {
+            assert!(projected_boxes.len() == 1);
+            let box_ = projected_boxes[0];
+            // TODO assert!(box_.isBox());
+            if ignore_placement {
+                self.ignored_grid.insert(
+                    IndexedSubfeature::new(
+                        feature.indexed_feature,
+                        bucket_instance_id,
+                        collision_group_id,
+                    ),
+                    *box_.box_(),
+                );
+            } else {
+                self.collision_grid.insert(
+                    IndexedSubfeature::new(
+                        feature.indexed_feature,
+                        bucket_instance_id,
+                        collision_group_id,
+                    ),
+                    *box_.box_(),
+                );
+            }
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: queryRenderedSymbols
+    pub fn query_rendered_symbols(
+        &self,
+        line_string: &ScreenLineString,
+    ) -> HashMap<u32, Vec<IndexedSubfeature>> {
+        todo!()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: projectTileBoundaries
+    pub fn project_tile_boundaries(&self, pos_matrix: &ModelViewProjection) -> CollisionBoundaries {
+        let top_left = self.project_point(pos_matrix, &Point2D::zero());
+        let bottom_right = self.project_point(pos_matrix, &Point2D::new(EXTENT, EXTENT)); // FIXME: maplibre-native uses here 8192 for extent
+
+        CollisionBoundaries::new(
+            Point2D::new(top_left.x, top_left.y),
+            Point2D::new(bottom_right.x, bottom_right.y),
+        )
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getTransformState
+    pub fn get_transform_state(&self) -> &TransformState {
+        &self.transform_state
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getViewportPadding
+    pub fn get_viewport_padding(&self) -> f64 {
+        self.viewport_padding
+    }
+}
+
+impl CollisionIndex {
+    /// maplibre/maplibre-native#4add9ea original name: isOffscreen
+    fn is_offscreen(&self, boundaries: &CollisionBoundaries) -> bool {
+        boundaries.max.x < self.viewport_padding
+            || boundaries.min.x >= self.screen_right_boundary
+            || boundaries.max.y < self.viewport_padding
+            || boundaries.min.y >= self.screen_bottom_boundary
+    }
+    /// maplibre/maplibre-native#4add9ea original name: isInsideGrid
+    fn is_inside_grid(&self, boundaries: &CollisionBoundaries) -> bool {
+        boundaries.max.x >= 0.
+            && boundaries.min.x < self.grid_right_boundary
+            && boundaries.max.y >= 0.
+            && boundaries.min.y < self.grid_bottom_boundary
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: isInsideTile
+    fn is_inside_tile(
+        &self,
+        boundaries: &CollisionBoundaries,
+        tile_boundaries: &CollisionBoundaries,
+    ) -> bool {
+        boundaries.min.x >= tile_boundaries.min.x
+            && boundaries.min.y >= tile_boundaries.min.y
+            && boundaries.max.x < tile_boundaries.max.x
+            && boundaries.max.y < tile_boundaries.max.y
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: overlapsTile
+    fn overlaps_tile(
+        &self,
+        boundaries: &CollisionBoundaries,
+        tile_boundaries: &CollisionBoundaries,
+    ) -> bool {
+        boundaries.min.x < tile_boundaries.max.x
+            && boundaries.max.x > tile_boundaries.min.x
+            && boundaries.min.y < tile_boundaries.max.y
+            && boundaries.max.y > tile_boundaries.min.y
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: placeLineFeature
+    fn place_line_feature<F>(
+        &self,
+        feature: &CollisionFeature,
+        pos_matrix: &ModelViewProjection,
+        label_plane_matrix: &Matrix4<f64>,
+        text_pixel_ratio: f64,
+        symbol: &PlacedSymbol,
+        scale: f64,
+        font_size: f64,
+        allow_overlap: bool,
+        pitch_with_map: bool,
+        collision_debug: bool,
+        avoid_edges: Option<CollisionBoundaries>,
+        collision_group_predicate: Option<F>,
+        projected_boxes: &mut Vec<ProjectedCollisionBox>, /*out*/
+    ) -> (bool, bool)
+    where
+        F: Fn(&IndexedSubfeature) -> bool,
+    {
+        assert!(feature.along_line);
+        assert!(projected_boxes.is_empty());
+        let tile_unit_anchor_point = symbol.anchor_point;
+        let projected_anchor = self.project_anchor(pos_matrix, &tile_unit_anchor_point);
+
+        let font_scale = font_size / 24.;
+        let line_offset_x = symbol.line_offset[0] * font_size;
+        let line_offset_y = symbol.line_offset[1] * font_size;
+
+        let label_plane_anchor_point = project(tile_unit_anchor_point, label_plane_matrix).0;
+
+        let first_and_last_glyph = place_first_and_last_glyph(
+            font_scale,
+            line_offset_x,
+            line_offset_y,
+            /*flip*/ false,
+            label_plane_anchor_point,
+            tile_unit_anchor_point,
+            symbol,
+            label_plane_matrix,
+            /*return tile distance*/ true,
+        );
+
+        let mut collision_detected = false;
+        let mut in_grid = false;
+        let mut entirely_offscreen = true;
+
+        let tile_to_viewport = projected_anchor.0 * text_pixel_ratio;
+        // pixelsToTileUnits is used for translating line geometry to tile units
+        // ... so we care about 'scale' but not 'perspectiveRatio'
+        // equivalent to pixel_to_tile_units
+        let pixels_to_tile_units = 1. / (text_pixel_ratio * scale);
+
+        let mut first_tile_distance = 0.;
+        let mut last_tile_distance = 0.;
+        if let Some(first_and_last_glyph) = &first_and_last_glyph {
+            first_tile_distance = self.approximate_tile_distance(
+                first_and_last_glyph.0.tile_distance.as_ref().unwrap(),
+                first_and_last_glyph.0.angle,
+                pixels_to_tile_units,
+                projected_anchor.1,
+                pitch_with_map,
+            );
+            last_tile_distance = self.approximate_tile_distance(
+                first_and_last_glyph.1.tile_distance.as_ref().unwrap(),
+                first_and_last_glyph.1.angle,
+                pixels_to_tile_units,
+                projected_anchor.1,
+                pitch_with_map,
+            );
+        }
+
+        let mut previous_circle_placed = false;
+        projected_boxes.resize(feature.boxes.len(), ProjectedCollisionBox::default());
+        for i in 0..feature.boxes.len() {
+            let circle = feature.boxes[i];
+            let box_signed_distance_from_anchor = circle.signed_distance_from_anchor;
+            if first_and_last_glyph.is_none()
+                || (box_signed_distance_from_anchor < -first_tile_distance)
+                || (box_signed_distance_from_anchor > last_tile_distance)
+            {
+                // The label either doesn't fit on its line or we
+                // don't need to use this circle because the label
+                // doesn't extend this far. Either way, mark the circle unused.
+                previous_circle_placed = false;
+                continue;
+            }
+
+            let projected_point = self.project_point(pos_matrix, &circle.anchor);
+            let tile_unit_radius = (circle.x2 - circle.x1) / 2.;
+            let radius = tile_unit_radius * tile_to_viewport;
+
+            if previous_circle_placed {
+                let previous_circle = &projected_boxes[i - 1];
+                assert!(previous_circle.is_circle());
+                let previous_center = previous_circle.circle().center;
+                let dx = projected_point.x - previous_center.x;
+                let dy = projected_point.y - previous_center.y;
+                // The circle edges touch when the distance between their centers is
+                // 2x the radius When the distance is 1x the radius, they're doubled
+                // up, and we could remove every other circle while keeping them all
+                // in touch. We actually start removing circles when the distance is
+                // √2x the radius:
+                //  thinning the number of circles as much as possible is a major
+                //  performance win, and the small gaps introduced don't make a very
+                //  noticeable difference.
+                let placed_too_densely = radius * radius * 2. > dx * dx + dy * dy;
+                if placed_too_densely {
+                    let at_least_one_more_circle = (i + 1) < feature.boxes.len();
+                    if at_least_one_more_circle {
+                        let next_circle = feature.boxes[i + 1];
+                        let next_box_distance_from_anchor = next_circle.signed_distance_from_anchor;
+                        if (next_box_distance_from_anchor > -first_tile_distance)
+                            && (next_box_distance_from_anchor < last_tile_distance)
+                        {
+                            // Hide significantly overlapping circles, unless this
+                            // is the last one we can use, in which case we want to
+                            // keep it in place even if it's tightly packed with the
+                            // one before it.
+                            previous_circle_placed = false;
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            previous_circle_placed = true;
+
+            let collision_boundaries = CollisionBoundaries::new(
+                Point2D::new(projected_point.x - radius, projected_point.y - radius),
+                Point2D::new(projected_point.x + radius, projected_point.y + radius),
+            );
+
+            projected_boxes[i] = ProjectedCollisionBox::Circle(Circle::new(
+                Point2D::new(projected_point.x, projected_point.y),
+                radius,
+            ));
+
+            entirely_offscreen &= self.is_offscreen(&collision_boundaries);
+            in_grid |= self.is_inside_grid(&collision_boundaries);
+
+            if let Some(avoid_edges) = avoid_edges {
+                if !self.is_inside_tile(&collision_boundaries, &avoid_edges) {
+                    if !collision_debug {
+                        return (false, false);
+                    } else {
+                        // Don't early exit if we're showing the debug circles because
+                        // we still want to calculate which circles are in use
+                        collision_detected = true;
+                    }
+                }
+            }
+
+            if !allow_overlap
+                && self.collision_grid.hit_test_circle(
+                    projected_boxes[i].circle(),
+                    collision_group_predicate.as_ref(),
+                )
+            {
+                if !collision_debug {
+                    return (false, false);
+                } else {
+                    // Don't early exit if we're showing the debug circles because
+                    // we still want to calculate which circles are in use
+                    collision_detected = true;
+                }
+            }
+        }
+
+        (
+            !collision_detected && first_and_last_glyph.is_some() && in_grid,
+            entirely_offscreen,
+        )
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: approximateTileDistance
+    fn approximate_tile_distance(
+        &self,
+        tile_distance: &TileDistance,
+        last_segment_angle: f64,
+        pixels_to_tile_units: f64,
+        camera_to_anchor_distance: f64,
+        pitch_with_map: bool,
+    ) -> f64 {
+        // This is a quick and dirty solution for chosing which collision circles to
+        // use (since collision circles are laid out in tile units). Ideally, I
+        // think we should generate collision circles on the fly in viewport
+        // coordinates at the time we do collision detection.
+
+        // incidenceStretch is the ratio of how much y space a label takes up on a
+        // tile while drawn perpendicular to the viewport vs
+        //  how much space it would take up if it were drawn flat on the tile
+        // Using law of sines, camera_to_anchor/sin(ground_angle) =
+        // camera_to_center/sin(incidence_angle) Incidence angle 90 -> head on,
+        // sin(incidence_angle) = 1, no stretch Incidence angle 1 -> very oblique,
+        // sin(incidence_angle) =~ 0, lots of stretch ground_angle = u_pitch + PI/2
+        // -> sin(ground_angle) = cos(u_pitch) incidenceStretch = 1 /
+        // sin(incidenceAngle)
+
+        let incidence_stretch = if pitch_with_map {
+            1.
+        } else {
+            camera_to_anchor_distance / self.pitch_factor
+        };
+        let last_segment_tile = tile_distance.last_segment_viewport_distance * pixels_to_tile_units;
+        tile_distance.prev_tile_distance
+            + last_segment_tile
+            + (incidence_stretch - 1.) * last_segment_tile * last_segment_angle.sin().abs()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: projectAnchor
+    fn project_anchor(
+        &self,
+        pos_matrix: &ModelViewProjection,
+        point: &Point2D<f64, TileSpace>,
+    ) -> (f64, f64) {
+        let p = Vector4::new(point.x, point.y, 0., 1.);
+        let p = pos_matrix.project(p); // TODO verify multiplication
+        (
+            0.5 + 0.5 * (self.transform_state.camera_to_center_distance() / p[3]),
+            p[3],
+        )
+    }
+    /// maplibre/maplibre-native#4add9ea original name: projectAndGetPerspectiveRatio
+    fn project_and_get_perspective_ratio(
+        &self,
+        pos_matrix: &ModelViewProjection,
+        point: &Point2D<f64, TileSpace>,
+    ) -> (Point2D<f64, ScreenSpace>, f64) {
+        let p = Vector4::new(point.x, point.y, 0., 1.);
+        let p = pos_matrix.project(p); // TODO verify multiplication
+        let width = self.transform_state.width();
+        let height = self.transform_state.height();
+        let ccd = self.transform_state.camera_to_center_distance();
+        (
+            Point2D::new(
+                ((p[0] / p[3] + 1.) / 2.) * width + self.viewport_padding,
+                ((-p[1] / p[3] + 1.) / 2.) * height + self.viewport_padding,
+            ),
+            // See perspective ratio comment in symbol_sdf.vertex
+            // We're doing collision detection in viewport space so we need
+            // to scale down boxes in the distance
+            0.5 + 0.5 * ccd / p[3],
+        )
+    }
+    /// maplibre/maplibre-native#4add9ea original name: projectPoint
+    fn project_point(
+        &self,
+        pos_matrix: &ModelViewProjection,
+        point: &Point2D<f64, TileSpace>,
+    ) -> Point2D<f64, ScreenSpace> {
+        let p = Vector4::new(point.x, point.y, 0., 1.);
+        let p = pos_matrix.project(p); // TODO verify multiplication
+        let width = self.transform_state.width();
+        let height = self.transform_state.height();
+        Point2D::new(
+            ((p[0] / p[3] + 1.) / 2.) * width + self.viewport_padding,
+            ((-p[1] / p[3] + 1.) / 2.) * height + self.viewport_padding,
+        )
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getProjectedCollisionBoundaries
+    fn get_projected_collision_boundaries(
+        &self,
+        pos_matrix: &ModelViewProjection,
+        shift: Point2D<f64, ScreenSpace>,
+        text_pixel_ratio: f64,
+        box_: &CollisionBox,
+    ) -> CollisionBoundaries {
+        let (projected_point, tile_to_viewport) =
+            self.project_and_get_perspective_ratio(pos_matrix, &box_.anchor);
+        let tile_to_viewport = text_pixel_ratio * tile_to_viewport;
+        let tile_to_viewport = 1.; // TODO
+        CollisionBoundaries::new(
+            Point2D::new(
+                (box_.x1 + shift.x) * tile_to_viewport + projected_point.x,
+                (box_.y1 + shift.y) * tile_to_viewport + projected_point.y,
+            ),
+            Point2D::new(
+                (box_.x2 + shift.x) * tile_to_viewport + projected_point.x,
+                (box_.y2 + shift.y) * tile_to_viewport + projected_point.y,
+            ),
+        )
+    }
+}
diff --git a/maplibre/src/legacy/font_stack.rs b/maplibre/src/legacy/font_stack.rs
new file mode 100644
index 000000000..5e3df9559
--- /dev/null
+++ b/maplibre/src/legacy/font_stack.rs
@@ -0,0 +1,46 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/util/font_stack.cpp
+
+use std::collections::BTreeSet;
+
+use crate::{legacy::util::hash_combine, style::layer::StyleLayer};
+
+// An array of font names
+/// maplibre/maplibre-native#4add9ea original name: FontStack
+pub type FontStack = Vec<String>;
+/// maplibre/maplibre-native#4add9ea original name: FontStackHash
+pub type FontStackHash = u64;
+
+/// maplibre/maplibre-native#4add9ea original name: FontStackHasher
+pub struct FontStackHasher;
+
+impl FontStackHasher {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(font_stack: &FontStack) -> u64 {
+        let mut seed = 0;
+        for font in font_stack {
+            hash_combine(&mut seed, font);
+        }
+        seed
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: fontStackToString
+pub fn font_stack_to_string(font_stack: &FontStack) -> String {
+    font_stack.join(",")
+}
+
+/// Statically evaluate layer properties to determine what font stacks are used.
+/// maplibre/maplibre-native#4add9ea original name: fontStacks
+pub fn font_stacks(layers: &Vec<StyleLayer>) -> BTreeSet<FontStack> {
+    let mut result = BTreeSet::new();
+    for layer in layers {
+        populate_font_stack(layer, &mut result);
+    }
+
+    result
+}
+
+/// maplibre/maplibre-native#4add9ea original name: populateFontStack
+pub(crate) fn populate_font_stack(layer: &StyleLayer, stack: &mut BTreeSet<FontStack>) {
+    todo!()
+}
diff --git a/maplibre/src/legacy/geometry/anchor.rs b/maplibre/src/legacy/geometry/anchor.rs
new file mode 100644
index 000000000..b7e9c44cb
--- /dev/null
+++ b/maplibre/src/legacy/geometry/anchor.rs
@@ -0,0 +1,14 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/geometry/anchor.hpp
+
+use crate::{euclid::Point2D, legacy::TileSpace};
+
+/// maplibre/maplibre-native#4add9ea original name: Anchor
+#[derive(Clone, Copy)]
+pub struct Anchor {
+    pub point: Point2D<f64, TileSpace>,
+    pub angle: f64,
+    pub segment: Option<usize>,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: Anchors
+pub type Anchors = Vec<Anchor>;
diff --git a/maplibre/src/legacy/geometry/feature_index.rs b/maplibre/src/legacy/geometry/feature_index.rs
new file mode 100644
index 000000000..a1c24b4ec
--- /dev/null
+++ b/maplibre/src/legacy/geometry/feature_index.rs
@@ -0,0 +1,45 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/geometry/feature_index.cpp
+
+/// maplibre/maplibre-native#4add9ea original name: IndexedSubfeature
+#[derive(Clone)]
+pub struct IndexedSubfeature {
+    pub ref_: RefIndexedSubfeature,
+    pub source_layer_name_copy: String,
+    pub bucket_leader_idcopy: String,
+}
+
+impl IndexedSubfeature {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        indexed_feature: IndexedSubfeature,
+        bucket_instance_id: u32,
+        collision_group_id: u16,
+    ) -> IndexedSubfeature {
+        IndexedSubfeature {
+            ref_: RefIndexedSubfeature {
+                index: indexed_feature.ref_.index,
+                sort_index: indexed_feature.ref_.sort_index,
+                source_layer_name: indexed_feature.ref_.source_layer_name.to_string(),
+                bucket_leader_id: indexed_feature.ref_.bucket_leader_id.to_string(),
+                bucket_instance_id,
+                collision_group_id,
+            },
+            source_layer_name_copy: indexed_feature.ref_.source_layer_name.to_string(),
+            bucket_leader_idcopy: indexed_feature.ref_.bucket_leader_id.to_string(),
+        }
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: RefIndexedSubfeature
+#[derive(Clone)]
+pub struct RefIndexedSubfeature {
+    pub index: usize,
+    pub sort_index: usize,
+
+    pub source_layer_name: String,
+    pub bucket_leader_id: String,
+
+    // Only used for symbol features
+    pub bucket_instance_id: u32,
+    pub collision_group_id: u16,
+}
diff --git a/maplibre/src/legacy/geometry/mod.rs b/maplibre/src/legacy/geometry/mod.rs
new file mode 100644
index 000000000..6d310dd47
--- /dev/null
+++ b/maplibre/src/legacy/geometry/mod.rs
@@ -0,0 +1,2 @@
+pub mod anchor;
+pub mod feature_index;
diff --git a/maplibre/src/legacy/geometry_tile_data.rs b/maplibre/src/legacy/geometry_tile_data.rs
new file mode 100644
index 000000000..fa966eb83
--- /dev/null
+++ b/maplibre/src/legacy/geometry_tile_data.rs
@@ -0,0 +1,95 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/tile/geometry_tile_data.cpp
+//! In maplibre-native GeometryTileFeature are traits/classes and there are impls for symbol, fill, line features etc.
+//! The same is true for the data objects which might be backed by geojson
+
+use std::ops::Index;
+
+use crate::{
+    euclid::Point2D,
+    legacy::{layout::symbol_feature::SymbolGeometryTileFeature, TileSpace},
+};
+
+/// maplibre/maplibre-native#4add9ea original name: GeometryCoordinate
+pub type GeometryCoordinate = Point2D<i16, TileSpace>;
+
+/// maplibre/maplibre-native#4add9ea original name: GeometryCoordinates(pub
+#[derive(Default, Clone, Debug)]
+pub struct GeometryCoordinates(pub Vec<GeometryCoordinate>);
+impl GeometryCoordinates {
+    /// maplibre/maplibre-native#4add9ea original name: len
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+impl Index<usize> for GeometryCoordinates {
+    /// maplibre/maplibre-native#4add9ea original name: Output
+    type Output = GeometryCoordinate;
+
+    /// maplibre/maplibre-native#4add9ea original name: index
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: GeometryCollection
+pub type GeometryCollection = Vec<GeometryCoordinates>;
+
+// TODO: The following types are not final
+/// maplibre/maplibre-native#4add9ea original name: Value
+pub type Value = geo_types::Geometry;
+/// maplibre/maplibre-native#4add9ea original name: Identifier
+pub type Identifier = String;
+/// maplibre/maplibre-native#4add9ea original name: PropertyMap
+pub type PropertyMap = serde_json::Value;
+
+/// maplibre/maplibre-native#4add9ea original name: FeatureType
+#[derive(PartialEq)]
+pub enum FeatureType {
+    Unknown = 0,
+    Point = 1,
+    LineString = 2,
+    Polygon = 3,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolGeometryTileLayer
+#[derive(Clone)]
+pub struct SymbolGeometryTileLayer {
+    pub name: String,
+    pub features: Vec<SymbolGeometryTileFeature>,
+}
+impl SymbolGeometryTileLayer {
+    /// maplibre/maplibre-native#4add9ea original name: featureCount
+    pub fn feature_count(&self) -> usize {
+        self.features.len()
+    }
+
+    // Returns the feature object at the given position within the layer. The
+    // returned feature object may *not* outlive the layer object.
+    /// maplibre/maplibre-native#4add9ea original name: getFeature
+    pub fn get_feature(&self, index: usize) -> Box<SymbolGeometryTileFeature> {
+        Box::new(self.features[index].clone())
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getName
+    pub fn get_name(&self) -> &str {
+        &self.name
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolGeometryTileData
+#[derive(Clone)]
+struct SymbolGeometryTileData;
+
+impl SymbolGeometryTileData {
+    /// maplibre/maplibre-native#4add9ea original name: clone
+    pub fn clone(&self) -> Box<SymbolGeometryTileData> {
+        todo!()
+    }
+
+    // Returns the layer with the given name. The returned layer object *may*
+    // outlive the data object.
+    /// maplibre/maplibre-native#4add9ea original name: getLayer
+    pub fn get_layer(&self, name: &str) -> Box<SymbolGeometryTileLayer> {
+        todo!()
+    }
+}
diff --git a/maplibre/src/legacy/glyph.rs b/maplibre/src/legacy/glyph.rs
new file mode 100644
index 000000000..9542e1dfa
--- /dev/null
+++ b/maplibre/src/legacy/glyph.rs
@@ -0,0 +1,155 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/text/glyph.cpp
+
+use std::collections::{BTreeMap, BTreeSet, HashSet};
+
+use bitflags::bitflags;
+
+use crate::{
+    euclid::Rect,
+    legacy::{
+        bidi::Char16,
+        font_stack::{FontStack, FontStackHash},
+        glyph_range::GlyphRange,
+        TileSpace,
+    },
+};
+
+// TODO structs
+/// maplibre/maplibre-native#4add9ea original name: AlphaImage
+#[derive(Default)]
+pub struct AlphaImage;
+
+/// maplibre/maplibre-native#4add9ea original name: GlyphID
+pub type GlyphID = Char16;
+/// maplibre/maplibre-native#4add9ea original name: GlyphIDs
+pub type GlyphIDs = BTreeSet<GlyphID>;
+
+// Note: this only works for the BMP
+/// maplibre/maplibre-native#4add9ea original name: getGlyphRange
+pub fn get_glyph_range(glyph: GlyphID) -> GlyphRange {
+    let mut start: u16 = (glyph / 256) * 256;
+    let mut end = start + 255;
+    if start > 65280 {
+        start = 65280;
+    }
+    if end > 65535 {
+        end = 65535;
+    }
+    start..end
+}
+
+/// maplibre/maplibre-native#4add9ea original name: GlyphMetrics
+#[derive(PartialEq, Default, Copy, Clone)]
+pub struct GlyphMetrics {
+    pub width: u32,
+    pub height: u32,
+    pub left: i32,
+    pub top: i32,
+    pub advance: u32,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: Glyph
+#[derive(Default)]
+pub struct Glyph {
+    // We're using this value throughout the Mapbox GL ecosystem. If this is
+    // different, the glyphs also need to be reencoded.
+    pub id: GlyphID,
+
+    // A signed distance field of the glyph with a border (see above).
+    pub bitmap: AlphaImage,
+
+    // Glyph metrics
+    pub metrics: GlyphMetrics,
+}
+
+impl Glyph {
+    pub const BORDER_SIZE: u8 = 3;
+}
+
+/// maplibre/maplibre-native#4add9ea original name: Glyphs
+pub type Glyphs = BTreeMap<GlyphID, Option<Glyph>>;
+/// maplibre/maplibre-native#4add9ea original name: GlyphMap
+pub type GlyphMap = BTreeMap<FontStackHash, Glyphs>;
+
+/// maplibre/maplibre-native#4add9ea original name: PositionedGlyph
+#[derive(Clone)]
+pub struct PositionedGlyph {
+    pub glyph: GlyphID,
+    pub x: f64,
+    pub y: f64,
+    pub vertical: bool,
+    pub font: FontStackHash,
+    pub scale: f64,
+    pub rect: Rect<u16, TileSpace>,
+    pub metrics: GlyphMetrics,
+    pub image_id: Option<String>,
+    // Maps positioned glyph to TaggedString section
+    pub section_index: usize,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PositionedLine
+#[derive(Default, Clone)]
+pub struct PositionedLine {
+    pub positioned_glyphs: Vec<PositionedGlyph>,
+    pub line_offset: f64,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: Shaping
+#[derive(Clone, Default)]
+pub struct Shaping {
+    pub positioned_lines: Vec<PositionedLine>,
+    pub top: f64,
+    pub bottom: f64,
+    pub left: f64,
+    pub right: f64,
+    pub writing_mode: WritingModeType,
+
+    pub verticalizable: bool,
+    pub icons_in_text: bool,
+}
+impl Shaping {
+    // The y offset *should* be part of the font metadata.
+    pub const Y_OFFSET: i32 = -17;
+
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(x: f64, y: f64, writing_mode: WritingModeType) -> Self {
+        Self {
+            positioned_lines: vec![],
+            top: y,
+            bottom: y,
+            left: x,
+            right: x,
+            writing_mode,
+            verticalizable: false,
+            icons_in_text: false,
+        }
+    }
+    /// maplibre/maplibre-native#4add9ea original name: isAnyLineNotEmpty
+    pub fn is_any_line_not_empty(&self) -> bool {
+        self.positioned_lines
+            .iter()
+            .any(|line| !line.positioned_glyphs.is_empty())
+    }
+}
+
+bitflags! {
+    /// maplibre/maplibre-native#4add9ea original name: WritingModeType:
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct WritingModeType: u8 {
+        const None = 0;
+        const Horizontal = 1 << 0;
+        const Vertical = 1 << 1;
+    }
+}
+
+impl Default for WritingModeType {
+    /// maplibre/maplibre-native#4add9ea original name: default
+    fn default() -> Self {
+        WritingModeType::None
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: GlyphDependencies
+pub type GlyphDependencies = BTreeMap<FontStack, GlyphIDs>;
+/// maplibre/maplibre-native#4add9ea original name: GlyphRangeDependencies
+pub type GlyphRangeDependencies = BTreeMap<FontStack, HashSet<GlyphRange>>;
diff --git a/maplibre/src/legacy/glyph_atlas.rs b/maplibre/src/legacy/glyph_atlas.rs
new file mode 100644
index 000000000..d253acbd4
--- /dev/null
+++ b/maplibre/src/legacy/glyph_atlas.rs
@@ -0,0 +1,39 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/text/glyph_atlas.cpp
+
+use std::collections::BTreeMap;
+
+use crate::{
+    euclid::Rect,
+    legacy::{
+        font_stack::FontStackHash,
+        glyph::{GlyphID, GlyphMap, GlyphMetrics},
+        TileSpace,
+    },
+};
+
+// TODO structs
+/// maplibre/maplibre-native#4add9ea original name: AlphaImage
+pub struct AlphaImage;
+
+/// maplibre/maplibre-native#4add9ea original name: GlyphPosition
+#[derive(Clone, Copy, Default)]
+pub struct GlyphPosition {
+    pub rect: Rect<u16, TileSpace>,
+    pub metrics: GlyphMetrics,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: GlyphPositionMap
+pub type GlyphPositionMap = BTreeMap<GlyphID, GlyphPosition>;
+/// maplibre/maplibre-native#4add9ea original name: GlyphPositions
+pub type GlyphPositions = BTreeMap<FontStackHash, GlyphPositionMap>;
+
+/// maplibre/maplibre-native#4add9ea original name: GlyphAtlas
+pub struct GlyphAtlas {
+    pub image: AlphaImage,
+    pub positions: GlyphPositions,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: makeGlyphAtlas
+pub fn make_glyph_atlas(glyphs: &GlyphMap) -> GlyphAtlas {
+    todo!() // Shelfpack library!
+}
diff --git a/maplibre/src/legacy/glyph_range.rs b/maplibre/src/legacy/glyph_range.rs
new file mode 100644
index 000000000..f1556028c
--- /dev/null
+++ b/maplibre/src/legacy/glyph_range.rs
@@ -0,0 +1,18 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/include/mbgl/text/glyph_range.hpp
+
+use std::ops::Range;
+
+use crate::legacy::util::hash;
+
+/// maplibre/maplibre-native#4add9ea original name: GlyphRange
+pub type GlyphRange = Range<u16>;
+
+const GLYPHS_PER_GLYPH_RANGE: u32 = 256;
+const GLYPH_RANGES_PER_FONT_STACK: u32 = 256;
+// 256 - 126 ranges skipped w/ i18n::allowsFixedWidthGlyphGeneration
+const NON_IDEOGRAPH_GLYPH_RANGES_PER_FONT_STACK: u32 = 130;
+
+/// maplibre/maplibre-native#4add9ea original name: hash_glyphrange
+fn hash_glyphrange(range: &GlyphRange) -> u64 {
+    hash(&[range.start, range.end])
+}
diff --git a/maplibre/src/legacy/grid_index.rs b/maplibre/src/legacy/grid_index.rs
new file mode 100644
index 000000000..8cab12151
--- /dev/null
+++ b/maplibre/src/legacy/grid_index.rs
@@ -0,0 +1,576 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/util/grid_index.hpp
+
+use std::{collections::HashSet, f64};
+
+use crate::{
+    euclid::{Box2D, Point2D},
+    legacy::ScreenSpace,
+};
+
+/// maplibre/maplibre-native#4add9ea original name: Circle
+#[derive(Default, Clone, Copy, Debug)]
+pub struct Circle<T> {
+    pub center: Point2D<T, ScreenSpace>,
+    pub radius: T,
+}
+
+impl<T> Circle<T> {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(center: Point2D<T, ScreenSpace>, radius: T) -> Circle<T> {
+        Self { center, radius }
+    }
+}
+
+impl<T: PartialEq> PartialEq for Circle<T> {
+    /// maplibre/maplibre-native#4add9ea original name: eq
+    fn eq(&self, other: &Self) -> bool {
+        self.center == other.center && self.radius == other.radius
+    }
+}
+
+impl<T: PartialEq> Eq for Circle<T> {}
+
+/// maplibre/maplibre-native#4add9ea original name: GridIndex
+pub struct GridIndex<T: Clone> {
+    width: f64,
+    height: f64,
+    x_cell_count: usize,
+    y_cell_count: usize,
+    x_scale: f64,
+    y_scale: f64,
+    estimated_elements_per_cell: usize,
+    box_elements: Vec<(T, Box2D<f64, ScreenSpace>)>,
+    circle_elements: Vec<(T, Circle<f64>)>,
+    box_cells: Vec<Vec<u32>>,
+    circle_cells: Vec<Vec<u32>>,
+}
+
+impl<T: Clone> GridIndex<T> {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(width: f64, height: f64, cell_size: u32) -> Self {
+        let x_cell_count = (width / cell_size as f64).ceil() as usize;
+        let y_cell_count = (height / cell_size as f64).ceil() as usize;
+
+        assert!(width > 0.0);
+        assert!(height > 0.0);
+        Self {
+            width,
+            height,
+            x_cell_count,
+            y_cell_count,
+            x_scale: x_cell_count as f64 / width,
+            y_scale: y_cell_count as f64 / height,
+            estimated_elements_per_cell: 0,
+            box_elements: vec![],
+            circle_elements: vec![],
+            box_cells: vec![vec![]; x_cell_count * y_cell_count],
+            circle_cells: vec![vec![]; x_cell_count * y_cell_count],
+        }
+    }
+
+    /// Set the expected number of elements per cell to avoid small re-allocations for populated cells
+    /// maplibre/maplibre-native#4add9ea original name: reserve
+    pub fn reserve(&mut self, value: usize) {
+        self.estimated_elements_per_cell = value;
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: insert
+    pub fn insert(&mut self, t: T, bbox: Box2D<f64, ScreenSpace>) {
+        assert!(self.box_elements.len() < u32::MAX as usize);
+        let uid = self.box_elements.len() as u32;
+
+        let cx1 = self.convert_to_x_cell_coord(bbox.min.x);
+        let cy1 = self.convert_to_y_cell_coord(bbox.min.y);
+        let cx2 = self.convert_to_x_cell_coord(bbox.max.x);
+        let cy2 = self.convert_to_y_cell_coord(bbox.max.y);
+
+        for x in cx1..=cx2 {
+            for y in cy1..=cy2 {
+                let cell = &mut self.box_cells[self.x_cell_count * y + x];
+                if self.estimated_elements_per_cell > 0 && cell.is_empty() {
+                    cell.reserve(self.estimated_elements_per_cell);
+                }
+                cell.push(uid);
+            }
+        }
+
+        self.box_elements.push((t, bbox));
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: insert_circle
+    pub fn insert_circle(&mut self, t: T, circle: Circle<f64>) {
+        assert!(self.circle_elements.len() < u32::MAX as usize);
+        let uid = self.circle_elements.len() as u32;
+
+        let cx1 = self.convert_to_x_cell_coord(circle.center.x - circle.radius);
+        let cy1 = self.convert_to_y_cell_coord(circle.center.y - circle.radius);
+        let cx2 = self.convert_to_x_cell_coord(circle.center.x + circle.radius);
+        let cy2 = self.convert_to_y_cell_coord(circle.center.y + circle.radius);
+
+        for x in cx1..=cx2 {
+            for y in cy1..=cy2 {
+                let cell = &mut self.circle_cells[self.x_cell_count * y + x];
+                if self.estimated_elements_per_cell > 0 && cell.is_empty() {
+                    cell.reserve(self.estimated_elements_per_cell);
+                }
+                cell.push(uid);
+            }
+        }
+
+        self.circle_elements.push((t, circle));
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: query
+    pub fn query(&self, query_box: &Box2D<f64, ScreenSpace>) -> Vec<T> {
+        let mut result = Vec::new();
+        self.query_internal(query_box, |t, bbox| -> bool {
+            result.push(t);
+            false
+        });
+        result
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: query_with_boxes
+    pub fn query_with_boxes(
+        &self,
+        query_box: &Box2D<f64, ScreenSpace>,
+    ) -> Vec<(T, Box2D<f64, ScreenSpace>)> {
+        let mut result = Vec::new();
+        self.query_internal(query_box, |t, bbox| -> bool {
+            result.push((t, bbox));
+            false
+        });
+        result
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: hit_test
+    pub fn hit_test<F>(&self, query_box: &Box2D<f64, ScreenSpace>, predicate: Option<F>) -> bool
+    where
+        F: Fn(&T) -> bool,
+    {
+        let mut hit = false;
+        self.query_internal(query_box, |t, _| -> bool {
+            if let Some(predicate) = &predicate {
+                if predicate(&t) {
+                    hit = true;
+                    true
+                } else {
+                    false
+                }
+            } else {
+                hit = true;
+                true
+            }
+        });
+        hit
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: hit_test_circle
+    pub fn hit_test_circle<F>(&self, circle: &Circle<f64>, predicate: Option<F>) -> bool
+    where
+        F: Fn(&T) -> bool,
+    {
+        let mut hit = false;
+        self.query_internal_circles(circle, |t, _| -> bool {
+            if let Some(predicate) = &predicate {
+                if predicate(&t) {
+                    hit = true;
+                    true
+                } else {
+                    false
+                }
+            } else {
+                hit = true;
+                true
+            }
+        });
+        hit
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: empty
+    pub fn empty(&self) -> bool {
+        self.box_elements.is_empty() && self.circle_elements.is_empty()
+    }
+}
+
+impl<T: Clone> GridIndex<T> {
+    /// maplibre/maplibre-native#4add9ea original name: no_intersection
+    fn no_intersection(&self, query_box: &Box2D<f64, ScreenSpace>) -> bool {
+        query_box.max.x < 0.0
+            || query_box.min.x >= self.width
+            || query_box.max.y < 0.0
+            || query_box.min.y >= self.height
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: complete_intersection
+    fn complete_intersection(&self, query_box: &Box2D<f64, ScreenSpace>) -> bool {
+        query_box.min.x <= 0.0
+            && query_box.min.y <= 0.0
+            && self.width <= query_box.max.x
+            && self.height <= query_box.max.y
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: convert_to_box
+    fn convert_to_box(circle: &Circle<f64>) -> Box2D<f64, ScreenSpace> {
+        Box2D::new(
+            Point2D::new(
+                circle.center.x - circle.radius,
+                circle.center.y - circle.radius,
+            ),
+            Point2D::new(
+                circle.center.x + circle.radius,
+                circle.center.y + circle.radius,
+            ),
+        )
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: query_internal
+    fn query_internal<F>(&self, query_bbox: &Box2D<f64, ScreenSpace>, mut result_fn: F)
+    where
+        F: FnMut(T, Box2D<f64, ScreenSpace>) -> bool,
+    {
+        let mut seen_boxes = HashSet::new();
+        let mut seen_circles = HashSet::new();
+
+        if self.no_intersection(query_bbox) {
+            return;
+        } else if self.complete_intersection(query_bbox) {
+            for element in &self.box_elements {
+                if result_fn(element.0.clone(), element.1) {
+                    return;
+                }
+            }
+            for element in &self.circle_elements {
+                if result_fn(element.0.clone(), Self::convert_to_box(&element.1)) {
+                    return;
+                }
+            }
+            return;
+        }
+
+        let cx1 = self.convert_to_x_cell_coord(query_bbox.min.x);
+        let cy1 = self.convert_to_y_cell_coord(query_bbox.min.y);
+        let cx2 = self.convert_to_x_cell_coord(query_bbox.max.x);
+        let cy2 = self.convert_to_y_cell_coord(query_bbox.max.y);
+
+        let mut cell_index;
+        for x in cx1..=cx2 {
+            for y in cy1..=cy2 {
+                cell_index = self.x_cell_count * y + x;
+                // Look up other boxes
+                for uid in &self.box_cells[cell_index] {
+                    if !seen_boxes.contains(&uid) {
+                        seen_boxes.insert(uid);
+
+                        let pair = &self.box_elements[*uid as usize];
+                        let bbox = pair.1;
+                        if Self::boxes_collide(query_bbox, &bbox) && result_fn(pair.0.clone(), bbox)
+                        {
+                            return;
+                        }
+                    }
+                }
+
+                // Look up circles
+                for uid in &self.circle_cells[cell_index] {
+                    if !seen_circles.contains(&uid) {
+                        seen_circles.insert(uid);
+
+                        let pair = &self.circle_elements[*uid as usize];
+                        let bcircle = &pair.1;
+                        if Self::circle_and_box_collide(bcircle, query_bbox)
+                            && result_fn(pair.0.clone(), Self::convert_to_box(bcircle))
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: query_internal_circles
+    fn query_internal_circles<F>(&self, query_bcircle: &Circle<f64>, mut result_fn: F)
+    where
+        F: FnMut(T, Box2D<f64, ScreenSpace>) -> bool,
+    {
+        let mut seen_boxes = HashSet::new();
+        let mut seen_circles = HashSet::new();
+
+        let query_bbox = Self::convert_to_box(query_bcircle);
+        if self.no_intersection(&query_bbox) {
+            return;
+        } else if self.complete_intersection(&query_bbox) {
+            for element in &self.box_elements {
+                if result_fn(element.0.clone(), element.1) {
+                    return;
+                }
+            }
+            for element in &self.circle_elements {
+                if result_fn(element.0.clone(), Self::convert_to_box(&element.1)) {
+                    return;
+                }
+            }
+        }
+
+        let cx1 = self.convert_to_x_cell_coord(query_bcircle.center.x - query_bcircle.radius);
+        let cy1 = self.convert_to_y_cell_coord(query_bcircle.center.y - query_bcircle.radius);
+        let cx2 = self.convert_to_x_cell_coord(query_bcircle.center.x + query_bcircle.radius);
+        let cy2 = self.convert_to_y_cell_coord(query_bcircle.center.y + query_bcircle.radius);
+
+        let mut cell_index;
+        for x in cx1..=cx2 {
+            for y in cy1..=cy2 {
+                cell_index = self.x_cell_count * y + x;
+                // Look up boxes
+                for uid in &self.box_cells[cell_index] {
+                    if !seen_boxes.contains(&uid) {
+                        seen_boxes.insert(uid);
+
+                        let pair = &self.box_elements[*uid as usize];
+                        let bbox = pair.1;
+                        if Self::circle_and_box_collide(query_bcircle, &bbox)
+                            && result_fn(pair.0.clone(), bbox)
+                        {
+                            return;
+                        }
+                    }
+                }
+
+                // Look up other circles
+                for uid in &self.circle_cells[cell_index] {
+                    if !seen_circles.contains(&uid) {
+                        seen_circles.insert(uid);
+
+                        let pair = &self.circle_elements[*uid as usize];
+                        let bcircle = &pair.1;
+                        if Self::circles_collide(query_bcircle, bcircle)
+                            && result_fn(pair.0.clone(), Self::convert_to_box(bcircle))
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: convert_to_x_cell_coord
+    fn convert_to_x_cell_coord(&self, x: f64) -> usize {
+        f64::max(
+            0.0,
+            f64::min((self.x_cell_count - 1) as f64, f64::floor(x * self.x_scale)),
+        ) as usize
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: convert_to_y_cell_coord
+    fn convert_to_y_cell_coord(&self, y: f64) -> usize {
+        f64::max(
+            0.0,
+            f64::min((self.y_cell_count - 1) as f64, f64::floor(y * self.y_scale)),
+        ) as usize
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: boxes_collide
+    fn boxes_collide(first: &Box2D<f64, ScreenSpace>, second: &Box2D<f64, ScreenSpace>) -> bool {
+        first.min.x <= second.max.x
+            && first.min.y <= second.max.y
+            && first.max.x >= second.min.x
+            && first.max.y >= second.min.y
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: circles_collide
+    fn circles_collide(first: &Circle<f64>, second: &Circle<f64>) -> bool {
+        let dx = second.center.x - first.center.x;
+        let dy = second.center.y - first.center.y;
+        let both_radii = first.radius + second.radius;
+        (both_radii * both_radii) > (dx * dx + dy * dy)
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: circle_and_box_collide
+    fn circle_and_box_collide(circle: &Circle<f64>, box_: &Box2D<f64, ScreenSpace>) -> bool {
+        let half_rect_width = (box_.max.x - box_.min.x) / 2.0;
+        let dist_x = (circle.center.x - (box_.min.x + half_rect_width)).abs();
+        if dist_x > (half_rect_width + circle.radius) {
+            return false;
+        }
+
+        let half_rect_height = (box_.max.y - box_.min.y) / 2.0;
+        let dist_y = (circle.center.y - (box_.min.y + half_rect_height)).abs();
+        if dist_y > (half_rect_height + circle.radius) {
+            return false;
+        }
+
+        if dist_x <= half_rect_width || dist_y <= half_rect_height {
+            return true;
+        }
+
+        let dx = dist_x - half_rect_width;
+        let dy = dist_y - half_rect_height;
+        (dx * dx + dy * dy) <= (circle.radius * circle.radius)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: indexes_features
+    fn indexes_features() {
+        let mut grid = GridIndex::<i16>::new(100.0, 100.0, 10);
+        grid.insert(
+            0,
+            Box2D::new(Point2D::new(4.0, 10.0), Point2D::new(6.0, 30.0)),
+        );
+        grid.insert(
+            1,
+            Box2D::new(Point2D::new(4.0, 10.0), Point2D::new(30.0, 12.0)),
+        );
+        grid.insert(
+            2,
+            Box2D::new(Point2D::new(-10.0, 30.0), Point2D::new(5.0, 35.0)),
+        );
+
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(4.0, 10.0),
+                Point2D::new(5.0, 11.0)
+            )),
+            vec![0i16, 1]
+        );
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(24.0, 10.0),
+                Point2D::new(25.0, 11.0)
+            )),
+            vec![1i16]
+        );
+        let vec1: Vec<i16> = vec![];
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(40.0, 40.0),
+                Point2D::new(100.0, 100.0)
+            )),
+            vec1
+        );
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(-6.0, 0.0),
+                Point2D::new(3.0, 100.0)
+            )),
+            vec![2i16]
+        );
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(-1000.0, -1000.0),
+                Point2D::new(1000.0, 1000.0)
+            )),
+            vec![0i16, 1, 2]
+        );
+    }
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: duplicate_keys
+    fn duplicate_keys() {
+        let mut grid = GridIndex::<i16>::new(100.0, 100.0, 10);
+        const KEY: i16 = 123;
+        grid.insert(
+            KEY,
+            Box2D::new(Point2D::new(3.0, 4.0), Point2D::new(4.0, 4.0)),
+        );
+        grid.insert(
+            KEY,
+            Box2D::new(Point2D::new(13.0, 13.0), Point2D::new(14.0, 14.0)),
+        );
+        grid.insert(
+            KEY,
+            Box2D::new(Point2D::new(23.0, 23.0), Point2D::new(24.0, 24.0)),
+        );
+
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(0.0, 0.0),
+                Point2D::new(30.0, 30.0)
+            )),
+            vec![KEY, KEY, KEY]
+        );
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: i16_closure
+    fn i16_closure() {}
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: circle_circle
+    fn circle_circle() {
+        let mut grid = GridIndex::<i16>::new(100.0, 100.0, 10);
+        grid.insert_circle(0, Circle::new(Point2D::new(50.0, 50.0), 10.0));
+        grid.insert_circle(1, Circle::new(Point2D::new(60.0, 60.0), 15.0));
+        grid.insert_circle(2, Circle::new(Point2D::new(-10.0, 110.0), 20.0));
+
+        assert!(grid.hit_test_circle::<Box<dyn Fn(&i16) -> bool>>(
+            &Circle::new(Point2D::new(55.0, 55.0), 2.0),
+            None
+        ));
+        assert!(!grid.hit_test_circle::<Box<dyn Fn(&i16) -> bool>>(
+            &Circle::new(Point2D::new(10.0, 10.0), 10.0),
+            None
+        ));
+        assert!(grid.hit_test_circle::<Box<dyn Fn(&i16) -> bool>>(
+            &Circle::new(Point2D::new(0.0, 100.0), 10.0),
+            None
+        ));
+        assert!(grid.hit_test_circle::<Box<dyn Fn(&i16) -> bool>>(
+            &Circle::new(Point2D::new(80.0, 60.0), 10.0),
+            None
+        ));
+    }
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: circle_box
+    fn circle_box() {
+        let mut grid = GridIndex::<i16>::new(100.0, 100.0, 10);
+        grid.insert_circle(0, Circle::new(Point2D::new(50.0, 50.0), 10.0));
+        grid.insert_circle(1, Circle::new(Point2D::new(60.0, 60.0), 15.0));
+        grid.insert_circle(2, Circle::new(Point2D::new(-10.0, 110.0), 20.0));
+
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(45.0, 45.0),
+                Point2D::new(55.0, 55.0)
+            )),
+            vec![0, 1]
+        );
+        let vec1: Vec<i16> = vec![];
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(0.0, 0.0),
+                Point2D::new(30.0, 30.0)
+            )),
+            vec1
+        );
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(0.0, 80.0),
+                Point2D::new(20.0, 100.0)
+            )),
+            vec![2]
+        );
+    }
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: indexes_features_overflow
+    fn indexes_features_overflow() {
+        let mut grid = GridIndex::<i16>::new(5000.0, 5000.0, 25);
+        grid.insert(
+            0,
+            Box2D::new(Point2D::new(4500.0, 4500.0), Point2D::new(4900.0, 4900.0)),
+        );
+        assert_eq!(
+            grid.query(&Box2D::new(
+                Point2D::new(4000.0, 4000.0),
+                Point2D::new(5000.0, 5000.0)
+            )),
+            vec![0]
+        );
+    }
+}
diff --git a/maplibre/src/legacy/image.rs b/maplibre/src/legacy/image.rs
new file mode 100644
index 000000000..720ed4eda
--- /dev/null
+++ b/maplibre/src/legacy/image.rs
@@ -0,0 +1,72 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/style/image.cpp
+
+use std::{cmp::Ordering, collections::HashMap};
+
+// TODO
+/// maplibre/maplibre-native#4add9ea original name: ImageManager
+pub struct ImageManager;
+/// maplibre/maplibre-native#4add9ea original name: PremultipliedImage
+pub struct PremultipliedImage;
+
+/// maplibre/maplibre-native#4add9ea original name: ImageStretch
+pub type ImageStretch = (f64, f64);
+/// maplibre/maplibre-native#4add9ea original name: ImageStretches
+pub type ImageStretches = Vec<ImageStretch>;
+
+/// maplibre/maplibre-native#4add9ea original name: ImageContent
+#[derive(Clone)]
+pub struct ImageContent {
+    pub left: f64,
+    pub top: f64,
+    pub right: f64,
+    pub bottom: f64,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: Image
+pub struct Image {
+    pub id: String,
+
+    image: PremultipliedImage,
+
+    // Pixel ratio of the sprite image.
+    pub pixel_ratio: f64,
+
+    // Whether this image should be interpreted as a signed distance field icon.
+    pub sdf: bool,
+
+    // Stretch areas of this image.
+    pub stretch_x: Option<ImageStretches>,
+    pub stretch_y: Option<ImageStretches>,
+
+    // The space where text can be fit into this image.
+    pub content: Option<ImageContent>,
+}
+
+impl PartialEq<Self> for Image {
+    /// maplibre/maplibre-native#4add9ea original name: eq
+    fn eq(&self, other: &Self) -> bool {
+        self.id.eq(&other.id)
+    }
+}
+
+impl PartialOrd<Self> for Image {
+    /// maplibre/maplibre-native#4add9ea original name: partial_cmp
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.id.partial_cmp(&other.id)
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: ImageType
+pub enum ImageType {
+    Icon,
+    Pattern,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: ImageMap
+pub type ImageMap = HashMap<String, Image>;
+/// maplibre/maplibre-native#4add9ea original name: ImageDependencies
+pub type ImageDependencies = HashMap<String, ImageType>;
+/// maplibre/maplibre-native#4add9ea original name: ImageRequestPair
+pub type ImageRequestPair = (ImageDependencies, u64);
+/// maplibre/maplibre-native#4add9ea original name: ImageVersionMap
+pub type ImageVersionMap = HashMap<String, u32>;
diff --git a/maplibre/src/legacy/image_atlas.rs b/maplibre/src/legacy/image_atlas.rs
new file mode 100644
index 000000000..7095d7809
--- /dev/null
+++ b/maplibre/src/legacy/image_atlas.rs
@@ -0,0 +1,92 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/renderer/image_atlas.cpp
+
+use std::collections::HashMap;
+
+use crate::{
+    euclid::Rect,
+    legacy::{
+        image::{
+            Image, ImageContent, ImageManager, ImageMap, ImageStretches, ImageVersionMap,
+            PremultipliedImage,
+        },
+        TileSpace,
+    },
+};
+
+/// maplibre/maplibre-native#4add9ea original name: ImagePosition
+#[derive(Clone)]
+pub struct ImagePosition {
+    pub pixel_ratio: f64,
+    pub padded_rect: Rect<u16, TileSpace>,
+    pub version: u32,
+    pub stretch_x: ImageStretches,
+    pub stretch_y: ImageStretches,
+    pub content: Option<ImageContent>,
+}
+impl ImagePosition {
+    pub const PADDING: u16 = 1;
+
+    /// maplibre/maplibre-native#4add9ea original name: tl
+    pub fn tl(&self) -> [u16; 2] {
+        [
+            (self.padded_rect.min().x + Self::PADDING),
+            (self.padded_rect.min().y + Self::PADDING),
+        ]
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: br
+    pub fn br(&self) -> [u16; 2] {
+        [
+            (self.padded_rect.min().x + self.padded_rect.width() - Self::PADDING),
+            (self.padded_rect.min().y + self.padded_rect.height() - Self::PADDING),
+        ]
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: tlbr
+    pub fn tlbr(&self) -> [u16; 4] {
+        let _tl = self.tl();
+        let _br = self.br();
+        [_tl[0], _tl[1], _br[0], _br[1]]
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: displaySize
+    pub fn display_size(&self) -> [f64; 2] {
+        [
+            (self.padded_rect.width() - Self::PADDING * 2) as f64 / self.pixel_ratio,
+            (self.padded_rect.height() - Self::PADDING * 2) as f64 / self.pixel_ratio,
+        ]
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: ImagePositions
+pub type ImagePositions = HashMap<String, ImagePosition>;
+
+/// maplibre/maplibre-native#4add9ea original name: ImagePatch
+pub struct ImagePatch {
+    image: Image,
+    padded_rect: Rect<u16, TileSpace>,
+}
+
+impl ImagePatch {}
+
+/// maplibre/maplibre-native#4add9ea original name: ImageAtlas
+pub struct ImageAtlas {
+    image: PremultipliedImage,
+    icon_positions: ImagePositions,
+    pattern_positions: ImagePositions,
+}
+impl ImageAtlas {
+    /// maplibre/maplibre-native#4add9ea original name: getImagePatchesAndUpdateVersions
+    pub fn get_image_patches_and_update_versions(image_manager: &ImageManager) -> Vec<ImagePatch> {
+        todo!()
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: makeImageAtlas
+pub fn make_image_atlas(
+    image_map_a: &ImageMap,
+    image_map_b: &ImageMap,
+    version_map: &ImageVersionMap,
+) -> ImageAtlas {
+    todo!()
+}
diff --git a/maplibre/src/legacy/layout/layout.rs b/maplibre/src/legacy/layout/layout.rs
new file mode 100644
index 000000000..a60762325
--- /dev/null
+++ b/maplibre/src/legacy/layout/layout.rs
@@ -0,0 +1,28 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/layout/layout.hpp
+
+use std::collections::BTreeSet;
+
+use crate::legacy::{
+    glyph::GlyphDependencies, image::ImageDependencies, MapMode, OverscaledTileID,
+};
+
+/// maplibre/maplibre-native#4add9ea original name: LayerTypeInfo
+#[derive(Clone)]
+pub struct LayerTypeInfo;
+
+/// maplibre/maplibre-native#4add9ea original name: BucketParameters
+#[derive(Clone)]
+pub struct BucketParameters {
+    pub tile_id: OverscaledTileID,
+    pub mode: MapMode,
+    pub pixel_ratio: f64,
+    pub layer_type: LayerTypeInfo,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: LayoutParameters
+pub struct LayoutParameters<'a> {
+    pub bucket_parameters: &'a mut BucketParameters,
+    pub glyph_dependencies: &'a mut GlyphDependencies,
+    pub image_dependencies: &'a mut ImageDependencies,
+    pub available_images: &'a mut BTreeSet<String>,
+}
diff --git a/maplibre/src/legacy/layout/mod.rs b/maplibre/src/legacy/layout/mod.rs
new file mode 100644
index 000000000..b8c1e0f37
--- /dev/null
+++ b/maplibre/src/legacy/layout/mod.rs
@@ -0,0 +1,5 @@
+pub mod layout;
+pub mod symbol_feature;
+pub mod symbol_instance;
+pub mod symbol_layout;
+pub mod symbol_projection;
diff --git a/maplibre/src/legacy/layout/symbol_feature.rs b/maplibre/src/legacy/layout/symbol_feature.rs
new file mode 100644
index 000000000..ce12e917e
--- /dev/null
+++ b/maplibre/src/legacy/layout/symbol_feature.rs
@@ -0,0 +1,79 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/layout/symbol_feature.hpp
+
+use std::cmp::Ordering;
+
+use crate::legacy::{
+    geometry_tile_data::{FeatureType, GeometryCollection, Identifier, Value},
+    style_types::expression,
+    tagged_string::TaggedString,
+};
+
+// TODO: Actual feature data with properties
+/// maplibre/maplibre-native#4add9ea original name: VectorGeometryTileFeature
+#[derive(Clone)]
+pub struct VectorGeometryTileFeature {
+    pub geometry: GeometryCollection,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolGeometryTileFeature
+#[derive(Clone)]
+pub struct SymbolGeometryTileFeature {
+    feature: Box<VectorGeometryTileFeature>,
+    pub geometry: GeometryCollection, // we need a mutable copy of the geometry for mergeLines()
+    pub formatted_text: Option<TaggedString>,
+    pub icon: Option<expression::Image>,
+    pub sort_key: f64,
+    pub index: usize,
+}
+
+impl PartialEq<Self> for SymbolGeometryTileFeature {
+    /// maplibre/maplibre-native#4add9ea original name: eq
+    fn eq(&self, other: &Self) -> bool {
+        self.sort_key.eq(&other.sort_key) // TODO is this correct?
+    }
+}
+
+impl PartialOrd for SymbolGeometryTileFeature {
+    /// maplibre/maplibre-native#4add9ea original name: partial_cmp
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.sort_key.partial_cmp(&other.sort_key)
+    }
+}
+
+impl SymbolGeometryTileFeature {
+    /// maplibre/maplibre-native#4add9ea original name: getType
+    pub fn get_type(&self) -> FeatureType {
+        //  todo!()
+        FeatureType::Point
+    }
+    /// maplibre/maplibre-native#4add9ea original name: getValue
+    pub fn get_value(&self, key: &str) -> Option<&Value> {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: getProperties
+    pub fn get_properties(&self) -> &serde_json::Value {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: getID
+    pub fn get_id(&self) -> Identifier {
+        todo!()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: getGeometries
+    pub fn get_geometries(&self) -> &GeometryCollection {
+        todo!()
+    }
+}
+
+impl SymbolGeometryTileFeature {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(feature: Box<VectorGeometryTileFeature>) -> Self {
+        Self {
+            geometry: feature.geometry.clone(), // we need a mutable copy of the geometry for mergeLines()
+            feature,
+            formatted_text: None,
+            icon: None,
+            sort_key: 0.0,
+            index: 0,
+        }
+    }
+}
diff --git a/maplibre/src/legacy/layout/symbol_instance.rs b/maplibre/src/legacy/layout/symbol_instance.rs
new file mode 100644
index 000000000..a9cf5d071
--- /dev/null
+++ b/maplibre/src/legacy/layout/symbol_instance.rs
@@ -0,0 +1,478 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/layout/symbol_instance.cpp
+
+use std::rc::Rc;
+
+use bitflags::bitflags;
+use widestring::U16String;
+
+use crate::legacy::{
+    collision_feature::CollisionFeature,
+    geometry::{anchor::Anchor, feature_index::IndexedSubfeature},
+    geometry_tile_data::GeometryCoordinates,
+    glyph::{Shaping, WritingModeType},
+    image::ImageMap,
+    quads::{get_glyph_quads, get_icon_quads, SymbolQuads},
+    shaping::PositionedIcon,
+    style_types::{SymbolLayoutProperties_Evaluated, SymbolPlacementType},
+};
+
+/// maplibre/maplibre-native#4add9ea original name: getAnyShaping
+fn get_any_shaping(shaped_text_orientations: &ShapedTextOrientations) -> &Shaping {
+    if shaped_text_orientations.right().is_any_line_not_empty() {
+        return shaped_text_orientations.right();
+    }
+    if shaped_text_orientations.center.is_any_line_not_empty() {
+        return &(shaped_text_orientations.center);
+    }
+    if shaped_text_orientations.left.is_any_line_not_empty() {
+        return &(shaped_text_orientations.left);
+    }
+    if shaped_text_orientations.vertical.is_any_line_not_empty() {
+        return &(shaped_text_orientations.vertical);
+    }
+    &shaped_text_orientations.horizontal
+}
+
+/// maplibre/maplibre-native#4add9ea original name: ShapedTextOrientations
+#[derive(Default)]
+pub struct ShapedTextOrientations {
+    horizontal: Shaping,
+    vertical: Shaping,
+    // The following are used with variable text placement on, including right()
+    center: Shaping,
+    left: Shaping,
+    pub single_line: bool,
+}
+
+impl ShapedTextOrientations {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        horizontal: Shaping,
+        vertical: Shaping,
+        right: Option<Shaping>,
+        center: Shaping,
+        left: Shaping,
+        single_line: bool,
+    ) -> Self {
+        Self {
+            horizontal: (horizontal),
+            vertical: (vertical),
+            center: (center),
+            left: (left),
+            single_line: single_line,
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: horizontal
+    pub fn horizontal(&self) -> &Shaping {
+        &self.horizontal
+    }
+    /// maplibre/maplibre-native#4add9ea original name: vertical
+    pub fn vertical(&self) -> &Shaping {
+        &self.vertical
+    }
+    /// maplibre/maplibre-native#4add9ea original name: right
+    pub fn right(&self) -> &Shaping {
+        &self.horizontal
+    }
+    /// maplibre/maplibre-native#4add9ea original name: center
+    pub fn center(&self) -> &Shaping {
+        &self.center
+    }
+    /// maplibre/maplibre-native#4add9ea original name: left
+    pub fn left(&self) -> &Shaping {
+        &self.left
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: set_horizontal
+    pub fn set_horizontal(&mut self, horizontal: Shaping) {
+        self.horizontal = horizontal;
+    }
+    /// maplibre/maplibre-native#4add9ea original name: set_vertical
+    pub fn set_vertical(&mut self, vertical: Shaping) {
+        self.vertical = vertical;
+    }
+}
+
+bitflags! {
+    /// maplibre/maplibre-native#4add9ea original name: SymbolContent:
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct SymbolContent: u8 {
+         const None = 0;
+         const Text = 1 << 0;
+         const IconRGBA = 1 << 1;
+         const IconSDF = 1 << 2;
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolInstanceSharedData
+#[derive(Default)]
+pub struct SymbolInstanceSharedData {
+    line: GeometryCoordinates,
+    // Note: When singleLine == true, only `rightJustifiedGlyphQuads` is populated.
+    right_justified_glyph_quads: SymbolQuads,
+    center_justified_glyph_quads: SymbolQuads,
+    left_justified_glyph_quads: SymbolQuads,
+    vertical_glyph_quads: SymbolQuads,
+    icon_quads: Option<SymbolQuads>,
+    vertical_icon_quads: Option<SymbolQuads>,
+}
+
+impl SymbolInstanceSharedData {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        line_: GeometryCoordinates,
+        shaped_text_orientations: &ShapedTextOrientations,
+        shaped_icon: Option<PositionedIcon>,
+        vertically_shaped_icon: Option<PositionedIcon>,
+        layout: &SymbolLayoutProperties_Evaluated,
+        text_placement: SymbolPlacementType,
+        text_offset: [f64; 2],
+        image_map: &ImageMap,
+        icon_rotation: f64,
+        icon_type: SymbolContent,
+        has_icon_text_fit: bool,
+        allow_vertical_placement: bool,
+    ) -> Self {
+        let mut self_ = Self {
+            line: line_,
+            ..Self::default()
+        };
+        // Create the quads used for rendering the icon and glyphs.
+        if let Some(shaped_icon) = &shaped_icon {
+            self_.icon_quads = Some(get_icon_quads(
+                shaped_icon,
+                icon_rotation,
+                icon_type,
+                has_icon_text_fit,
+            ));
+            if let Some(vertically_shaped_icon) = &vertically_shaped_icon {
+                self_.vertical_icon_quads = Some(get_icon_quads(
+                    vertically_shaped_icon,
+                    icon_rotation,
+                    icon_type,
+                    has_icon_text_fit,
+                ));
+            }
+        }
+
+        // todo is this translation correct?
+        if !shaped_text_orientations.single_line {
+            if shaped_text_orientations.right().is_any_line_not_empty() {
+                self_.right_justified_glyph_quads = get_glyph_quads(
+                    shaped_text_orientations.right(),
+                    text_offset,
+                    layout,
+                    text_placement,
+                    image_map,
+                    allow_vertical_placement,
+                );
+            }
+
+            if shaped_text_orientations.center.is_any_line_not_empty() {
+                self_.center_justified_glyph_quads = get_glyph_quads(
+                    &shaped_text_orientations.center,
+                    text_offset,
+                    layout,
+                    text_placement,
+                    image_map,
+                    allow_vertical_placement,
+                );
+            }
+
+            if shaped_text_orientations.left.is_any_line_not_empty() {
+                self_.left_justified_glyph_quads = get_glyph_quads(
+                    &shaped_text_orientations.left,
+                    text_offset,
+                    layout,
+                    text_placement,
+                    image_map,
+                    allow_vertical_placement,
+                );
+            }
+        } else {
+            let shape = if shaped_text_orientations.right().is_any_line_not_empty() {
+                Some(shaped_text_orientations.right())
+            } else if shaped_text_orientations.center.is_any_line_not_empty() {
+                Some(&shaped_text_orientations.center)
+            } else if shaped_text_orientations.left.is_any_line_not_empty() {
+                Some(&shaped_text_orientations.left)
+            } else {
+                None
+            };
+
+            if let Some(shape) = shape {
+                self_.right_justified_glyph_quads = get_glyph_quads(
+                    shape,
+                    text_offset,
+                    layout,
+                    text_placement,
+                    image_map,
+                    allow_vertical_placement,
+                );
+            }
+        }
+
+        if shaped_text_orientations.vertical.is_any_line_not_empty() {
+            self_.vertical_glyph_quads = get_glyph_quads(
+                &shaped_text_orientations.vertical,
+                text_offset,
+                layout,
+                text_placement,
+                image_map,
+                allow_vertical_placement,
+            );
+        }
+        self_
+    }
+    /// maplibre/maplibre-native#4add9ea original name: empty
+    fn empty(&self) -> bool {
+        self.right_justified_glyph_quads.is_empty()
+            && self.center_justified_glyph_quads.is_empty()
+            && self.left_justified_glyph_quads.is_empty()
+            && self.vertical_glyph_quads.is_empty()
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolInstance
+#[derive(Clone)]
+pub struct SymbolInstance {
+    shared_data: Rc<SymbolInstanceSharedData>,
+
+    pub anchor: Anchor,
+    pub symbol_content: SymbolContent,
+
+    pub right_justified_glyph_quads_size: usize,
+    pub center_justified_glyph_quads_size: usize,
+    pub left_justified_glyph_quads_size: usize,
+    pub vertical_glyph_quads_size: usize,
+    pub icon_quads_size: usize,
+
+    pub text_collision_feature: CollisionFeature,
+    pub icon_collision_feature: CollisionFeature,
+    pub vertical_text_collision_feature: Option<CollisionFeature>,
+    pub vertical_icon_collision_feature: Option<CollisionFeature>,
+    pub writing_modes: WritingModeType,
+    pub layout_feature_index: usize, // Index into the set of features included at layout time
+    pub data_feature_index: usize,   // Index into the underlying tile data feature set
+    pub text_offset: [f64; 2],
+    pub icon_offset: [f64; 2],
+    pub key: U16String,
+    pub placed_right_text_index: Option<usize>,
+    pub placed_center_text_index: Option<usize>,
+    pub placed_left_text_index: Option<usize>,
+    pub placed_vertical_text_index: Option<usize>,
+    pub placed_icon_index: Option<usize>,
+    pub placed_vertical_icon_index: Option<usize>,
+    pub text_box_scale: f64,
+    pub variable_text_offset: [f64; 2],
+    pub single_line: bool,
+    pub cross_tile_id: u32,
+}
+
+impl SymbolInstance {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        anchor_: Anchor,
+        shared_data: Rc<SymbolInstanceSharedData>,
+        shaped_text_orientations: &ShapedTextOrientations,
+        shaped_icon: &Option<PositionedIcon>,
+        vertically_shaped_icon: &Option<PositionedIcon>,
+        text_box_scale: f64,
+        text_padding: f64,
+        text_placement: SymbolPlacementType,
+        text_offset: [f64; 2],
+        icon_box_scale: f64,
+        icon_padding: f64,
+        icon_offset: [f64; 2],
+        indexed_feature: IndexedSubfeature,
+        layout_feature_index: usize,
+        data_feature_index: usize,
+        key_: U16String,
+        overscaling: f64,
+        icon_rotation: f64,
+        text_rotation: f64,
+        variable_text_offset: [f64; 2],
+        allow_vertical_placement: bool,
+        icon_type: SymbolContent,
+    ) -> Self {
+        let mut self_ = Self {
+            symbol_content: icon_type,
+            // Create the collision features that will be used to check whether this
+            // symbol instance can be placed As a collision approximation, we can use
+            // either the vertical or any of the horizontal versions of the feature
+            text_collision_feature: CollisionFeature::new_from_text(
+                &shared_data.line,
+                &anchor_,
+                get_any_shaping(shaped_text_orientations).clone(),
+                text_box_scale,
+                text_padding,
+                text_placement,
+                indexed_feature.clone(),
+                overscaling,
+                text_rotation,
+            ),
+            icon_collision_feature: CollisionFeature::new_from_icon(
+                &shared_data.line,
+                &anchor_,
+                shaped_icon,
+                icon_box_scale,
+                icon_padding,
+                indexed_feature.clone(),
+                icon_rotation,
+            ),
+
+            shared_data: shared_data,
+            anchor: anchor_,
+            writing_modes: WritingModeType::None,
+            layout_feature_index: layout_feature_index,
+            data_feature_index: data_feature_index,
+            text_offset: text_offset,
+            icon_offset: icon_offset,
+            key: key_,
+
+            text_box_scale: text_box_scale,
+            variable_text_offset: variable_text_offset,
+            single_line: shaped_text_orientations.single_line,
+
+            right_justified_glyph_quads_size: 0,
+            center_justified_glyph_quads_size: 0,
+            left_justified_glyph_quads_size: 0,
+            vertical_glyph_quads_size: 0,
+            icon_quads_size: 0,
+
+            vertical_text_collision_feature: None,
+            placed_right_text_index: None,
+            placed_center_text_index: None,
+            placed_left_text_index: None,
+            placed_vertical_text_index: None,
+            placed_icon_index: None,
+            placed_vertical_icon_index: None,
+
+            vertical_icon_collision_feature: None,
+            cross_tile_id: 0,
+        };
+
+        // 'hasText' depends on finding at least one glyph in the shaping that's also in the GlyphPositionMap
+        if !self_.shared_data.empty() {
+            self_.symbol_content |= SymbolContent::Text;
+        }
+        if allow_vertical_placement && shaped_text_orientations.vertical.is_any_line_not_empty() {
+            let vertical_point_label_angle = 90.0;
+            self_.vertical_text_collision_feature = Some(CollisionFeature::new_from_text(
+                self_.line(),
+                &self_.anchor,
+                shaped_text_orientations.vertical.clone(),
+                text_box_scale,
+                text_padding,
+                text_placement,
+                indexed_feature.clone(),
+                overscaling,
+                text_rotation + vertical_point_label_angle,
+            ));
+            if vertically_shaped_icon.is_some() {
+                self_.vertical_icon_collision_feature = Some(CollisionFeature::new_from_icon(
+                    &self_.shared_data.line,
+                    &self_.anchor,
+                    vertically_shaped_icon,
+                    icon_box_scale,
+                    icon_padding,
+                    indexed_feature,
+                    icon_rotation + vertical_point_label_angle,
+                ));
+            }
+        }
+
+        self_.right_justified_glyph_quads_size =
+            self_.shared_data.right_justified_glyph_quads.len();
+        self_.center_justified_glyph_quads_size =
+            self_.shared_data.center_justified_glyph_quads.len();
+        self_.left_justified_glyph_quads_size = self_.shared_data.left_justified_glyph_quads.len();
+        self_.vertical_glyph_quads_size = self_.shared_data.vertical_glyph_quads.len();
+
+        self_.icon_quads_size = if let Some(icon_quads) = &self_.shared_data.icon_quads {
+            icon_quads.len()
+        } else {
+            0
+        };
+
+        if self_.right_justified_glyph_quads_size != 0
+            || self_.center_justified_glyph_quads_size != 0
+            || self_.left_justified_glyph_quads_size != 0
+        {
+            self_.writing_modes |= WritingModeType::Horizontal;
+        }
+
+        if self_.vertical_glyph_quads_size != 0 {
+            self_.writing_modes |= WritingModeType::Vertical;
+        }
+
+        self_
+    }
+    /// maplibre/maplibre-native#4add9ea original name: getDefaultHorizontalPlacedTextIndex
+    pub fn get_default_horizontal_placed_text_index(&self) -> Option<usize> {
+        if let Some(index) = self.placed_right_text_index {
+            return Some(index);
+        }
+        if let Some(index) = self.placed_center_text_index {
+            return Some(index);
+        }
+        if let Some(index) = self.placed_left_text_index {
+            return Some(index);
+        }
+        None
+    }
+    /// maplibre/maplibre-native#4add9ea original name: line
+    pub fn line(&self) -> &GeometryCoordinates {
+        &self.shared_data.line
+    }
+    /// maplibre/maplibre-native#4add9ea original name: rightJustifiedGlyphQuads
+    pub fn right_justified_glyph_quads(&self) -> &SymbolQuads {
+        &self.shared_data.right_justified_glyph_quads
+    }
+    /// maplibre/maplibre-native#4add9ea original name: leftJustifiedGlyphQuads
+    pub fn left_justified_glyph_quads(&self) -> &SymbolQuads {
+        &self.shared_data.left_justified_glyph_quads
+    }
+    /// maplibre/maplibre-native#4add9ea original name: centerJustifiedGlyphQuads
+    pub fn center_justified_glyph_quads(&self) -> &SymbolQuads {
+        &self.shared_data.center_justified_glyph_quads
+    }
+    /// maplibre/maplibre-native#4add9ea original name: verticalGlyphQuads
+    pub fn vertical_glyph_quads(&self) -> &SymbolQuads {
+        &self.shared_data.vertical_glyph_quads
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasText
+    pub fn has_text(&self) -> bool {
+        self.symbol_content.contains(SymbolContent::Text) // TODO Is this correct?
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasIcon
+    pub fn has_icon(&self) -> bool {
+        self.symbol_content.contains(SymbolContent::IconRGBA) || self.has_sdf_icon()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasSdfIcon
+    pub fn has_sdf_icon(&self) -> bool {
+        self.symbol_content.contains(SymbolContent::IconSDF)
+    }
+    /// maplibre/maplibre-native#4add9ea original name: iconQuads
+    pub fn icon_quads(&self) -> &Option<SymbolQuads> {
+        &self.shared_data.icon_quads
+    }
+    /// maplibre/maplibre-native#4add9ea original name: verticalIconQuads
+    pub fn vertical_icon_quads(&self) -> &Option<SymbolQuads> {
+        &self.shared_data.vertical_icon_quads
+    }
+    /// maplibre/maplibre-native#4add9ea original name: releaseSharedData
+    pub fn release_shared_data(&self) {
+        // todo!()
+        // TODO not sure how to do this self.sharedData.reset();
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: invalidCrossTileID
+    fn invalid_cross_tile_id() -> u32 {
+        u32::MAX
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolInstanceReferences
+type SymbolInstanceReferences = Vec<SymbolInstance>;
diff --git a/maplibre/src/legacy/layout/symbol_layout.rs b/maplibre/src/legacy/layout/symbol_layout.rs
new file mode 100644
index 000000000..f8f4746dc
--- /dev/null
+++ b/maplibre/src/legacy/layout/symbol_layout.rs
@@ -0,0 +1,1893 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/layout/symbol_layout.cpp
+
+use std::{
+    collections::{BTreeMap, BTreeSet, HashMap},
+    f64::consts::PI,
+    ops::Range,
+    rc::Rc,
+};
+
+use lyon::geom::euclid::Point2D;
+use widestring::U16String;
+
+use crate::{
+    coords::{EXTENT, TILE_SIZE},
+    legacy::{
+        bidi::{apply_arabic_shaping, BiDi, Char16},
+        buckets::symbol_bucket::{
+            DynamicVertex, OpacityVertex, PlacedSymbol, Segment, SymbolBucket, SymbolBucketBuffer,
+            SymbolVertex,
+        },
+        geometry::{
+            anchor::{Anchor, Anchors},
+            feature_index::{IndexedSubfeature, RefIndexedSubfeature},
+        },
+        geometry_tile_data::{FeatureType, GeometryCoordinates, SymbolGeometryTileLayer},
+        glyph::{GlyphIDs, GlyphMap, Shaping, WritingModeType},
+        glyph_atlas::GlyphPositions,
+        image::{ImageMap, ImageType},
+        image_atlas::ImagePositions,
+        layout::{
+            layout::{BucketParameters, LayoutParameters},
+            symbol_feature::SymbolGeometryTileFeature,
+            symbol_instance::{
+                ShapedTextOrientations, SymbolContent, SymbolInstance, SymbolInstanceSharedData,
+            },
+        },
+        quads::{SymbolQuad, SymbolQuads},
+        shaping::{get_anchor_justification, get_shaping, PositionedIcon},
+        style_types::*,
+        tagged_string::{SectionOptions, TaggedString},
+        util::{constants::ONE_EM, i18n, lower_bound, math::deg2radf},
+        CanonicalTileID, MapMode,
+    },
+};
+
+// TODO
+/// maplibre/maplibre-native#4add9ea original name: SymbolLayer
+#[derive(Clone, Debug)]
+pub struct SymbolLayer {
+    pub layout: SymbolLayoutProperties_Unevaluated,
+}
+/// maplibre/maplibre-native#4add9ea original name: SymbolLayer_Impl
+pub type SymbolLayer_Impl = SymbolLayer;
+// TODO
+/// maplibre/maplibre-native#4add9ea original name: LayerProperties
+#[derive(Clone, Debug)]
+pub struct LayerProperties {
+    pub id: String,
+    pub layer: SymbolLayer_Impl,
+}
+/// maplibre/maplibre-native#4add9ea original name: SymbolLayerProperties
+pub type SymbolLayerProperties = LayerProperties;
+impl LayerProperties {
+    /// maplibre/maplibre-native#4add9ea original name: layerImpl
+    pub fn layer_impl(&self) -> &SymbolLayer_Impl {
+        // TODO
+        &self.layer
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: baseImpl
+    pub fn base_impl(&self) -> &Self {
+        self
+    }
+}
+/// maplibre/maplibre-native#4add9ea original name: Bucket
+pub type Bucket = SymbolBucket;
+
+/// maplibre/maplibre-native#4add9ea original name: LayerRenderData
+#[derive(Debug)]
+pub struct LayerRenderData {
+    pub bucket: Bucket,
+    pub layer_properties: LayerProperties,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SortKeyRange
+#[derive(Clone, Copy, Debug)]
+pub struct SortKeyRange {
+    sort_key: f64,
+    start: usize,
+    end: usize,
+}
+
+impl SortKeyRange {
+    /// maplibre/maplibre-native#4add9ea original name: isFirstRange
+    pub fn is_first_range(&self) -> bool {
+        self.start == 0
+    }
+}
+
+// index
+/// maplibre/maplibre-native#4add9ea original name: FeatureIndex
+pub struct FeatureIndex;
+
+/// maplibre/maplibre-native#4add9ea original name: sectionOptionsToValue
+fn section_options_to_value(options: &SectionOptions) -> expression::Value {
+    let mut result: HashMap<String, expression::Value> = Default::default();
+    // TODO: Data driven properties that can be overridden on per section basis.
+    // TextOpacity
+    // TextHaloColor
+    // TextHaloWidth
+    // TextHaloBlur
+    if let Some(text_color) = &(options.text_color) {
+        result.insert(
+            expression::K_FORMATTED_SECTION_TEXT_COLOR.to_string(),
+            expression::Value::Color(text_color.clone()),
+        );
+    }
+    expression::Value::Object(result)
+}
+
+/// maplibre/maplibre-native#4add9ea original name: toSymbolLayerProperties
+fn to_symbol_layer_properties(layer: &LayerProperties) -> &SymbolLayerProperties {
+    // TODO
+    //return static_cast<const SymbolLayerProperties&>(*layer);
+    layer
+}
+
+/// maplibre/maplibre-native#4add9ea original name: createLayout
+fn create_layout(
+    unevaluated: &SymbolLayoutProperties_Unevaluated,
+    zoom: f64,
+) -> SymbolLayoutProperties_PossiblyEvaluated {
+    let mut layout = unevaluated.evaluate(PropertyEvaluationParameters(zoom));
+
+    if layout.get::<IconRotationAlignment>() == AlignmentType::Auto {
+        if layout.get::<SymbolPlacement>() != SymbolPlacementType::Point {
+            layout.set::<IconRotationAlignment>(AlignmentType::Map);
+        } else {
+            layout.set::<IconRotationAlignment>(AlignmentType::Viewport);
+        }
+    }
+
+    if layout.get::<TextRotationAlignment>() == AlignmentType::Auto {
+        if layout.get::<SymbolPlacement>() != SymbolPlacementType::Point {
+            layout.set::<TextRotationAlignment>(AlignmentType::Map);
+        } else {
+            layout.set::<TextRotationAlignment>(AlignmentType::Viewport);
+        }
+    }
+
+    // If unspecified `*-pitch-alignment` inherits `*-rotation-alignment`
+    if layout.get::<TextPitchAlignment>() == AlignmentType::Auto {
+        layout.set::<TextPitchAlignment>(layout.get::<TextRotationAlignment>());
+    }
+    if layout.get::<IconPitchAlignment>() == AlignmentType::Auto {
+        layout.set::<IconPitchAlignment>(layout.get::<IconRotationAlignment>());
+    }
+
+    layout
+}
+
+// The radial offset is to the edge of the text box
+// In the horizontal direction, the edge of the text box is where glyphs start
+// But in the vertical direction, the glyphs appear to "start" at the baseline
+// We don't actually load baseline data, but we assume an offset of ONE_EM - 17
+// (see "yOffset" in shaping.js)
+const BASELINE_OFFSET: f64 = 7.0;
+
+// We don't care which shaping we get because this is used for collision
+// purposes and all the justifications have the same collision box.
+/// maplibre/maplibre-native#4add9ea original name: getDefaultHorizontalShaping
+fn get_default_horizontal_shaping(shaped_text_orientations: &ShapedTextOrientations) -> &Shaping {
+    if shaped_text_orientations.right().is_any_line_not_empty() {
+        return shaped_text_orientations.right();
+    }
+    if shaped_text_orientations.center().is_any_line_not_empty() {
+        return shaped_text_orientations.center();
+    }
+    if shaped_text_orientations.left().is_any_line_not_empty() {
+        return shaped_text_orientations.left();
+    }
+    return shaped_text_orientations.horizontal();
+}
+
+/// maplibre/maplibre-native#4add9ea original name: shapingForTextJustifyType
+fn shaping_for_text_justify_type(
+    shaped_text_orientations: &ShapedTextOrientations,
+    type_: TextJustifyType,
+) -> &Shaping {
+    match type_ {
+        TextJustifyType::Right => {
+            return shaped_text_orientations.right();
+        }
+
+        TextJustifyType::Left => {
+            return shaped_text_orientations.left();
+        }
+
+        TextJustifyType::Center => {
+            return shaped_text_orientations.center();
+        }
+        _ => {
+            assert!(false);
+            return shaped_text_orientations.horizontal();
+        }
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: evaluateRadialOffset
+fn evaluate_radial_offset(anchor: SymbolAnchorType, mut radial_offset: f64) -> [f64; 2] {
+    let mut result = [0.0, 0.0];
+    if radial_offset < 0.0 {
+        radial_offset = 0.0; // Ignore negative offset.
+    }
+    // solve for r where r^2 + r^2 = radialOffset^2
+    let sqrt2 = 1.41421356237;
+    let hypotenuse = radial_offset / sqrt2;
+
+    match anchor {
+        SymbolAnchorType::TopRight | SymbolAnchorType::TopLeft => {
+            result[1] = hypotenuse - BASELINE_OFFSET;
+        }
+
+        SymbolAnchorType::BottomRight | SymbolAnchorType::BottomLeft => {
+            result[1] = -hypotenuse + BASELINE_OFFSET;
+        }
+        SymbolAnchorType::Bottom => {
+            result[1] = -radial_offset + BASELINE_OFFSET;
+        }
+        SymbolAnchorType::Top => {
+            result[1] = radial_offset - BASELINE_OFFSET;
+        }
+
+        _ => {}
+    }
+
+    match anchor {
+        SymbolAnchorType::TopRight | SymbolAnchorType::BottomRight => {
+            result[0] = -hypotenuse;
+        }
+        SymbolAnchorType::TopLeft | SymbolAnchorType::BottomLeft => {
+            result[0] = hypotenuse;
+        }
+        SymbolAnchorType::Left => {
+            result[0] = radial_offset;
+        }
+        SymbolAnchorType::Right => {
+            result[0] = -radial_offset;
+        }
+
+        _ => {}
+    }
+
+    result
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolLayout
+pub struct SymbolLayout {
+    pub layer_paint_properties: BTreeMap<String, LayerProperties>,
+    pub bucket_leader_id: String,
+    pub symbol_instances: Vec<SymbolInstance>,
+    pub sort_key_ranges: Vec<SortKeyRange>,
+
+    // Stores the layer so that we can hold on to GeometryTileFeature instances
+    // in SymbolFeature, which may reference data from this object.
+    source_layer: Box<SymbolGeometryTileLayer>,
+    overscaling: f64,
+    zoom: f64,
+    canonical_id: CanonicalTileID,
+    mode: MapMode,
+    pixel_ratio: f64,
+
+    tile_size: u32,
+    tile_pixel_ratio: f64,
+
+    icons_need_linear: bool,
+    sort_features_by_y: bool,
+    sort_features_by_key: bool,
+    allow_vertical_placement: bool,
+    icons_in_text: bool,
+    placement_modes: Vec<TextWritingModeType>,
+
+    text_size: <TextSize as DataDrivenLayoutProperty>::UnevaluatedType,
+    icon_size: <IconSize as DataDrivenLayoutProperty>::UnevaluatedType,
+    text_radial_offset: <TextRadialOffset as DataDrivenLayoutProperty>::UnevaluatedType,
+    layout: SymbolLayoutProperties_PossiblyEvaluated,
+    features: Vec<SymbolGeometryTileFeature>,
+
+    bidi: BiDi, // Consider moving this up to geometry tile worker to reduce
+    // reinstantiation costs, use of BiDi/ubiditransform object must
+    // be rained to one thread
+    compare_text: BTreeMap<U16String, Vec<Anchor>>,
+}
+
+impl SymbolLayout {
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(
+        parameters: &BucketParameters,
+        layers: &Vec<LayerProperties>,
+        source_layer: Box<SymbolGeometryTileLayer>,
+        layout_parameters: &mut LayoutParameters, // TODO is this output?
+    ) -> Option<Self> {
+        let overscaling = parameters.tile_id.overscale_factor() as f64;
+        let zoom = parameters.tile_id.overscaled_z as f64;
+        let tile_size = (TILE_SIZE * overscaling) as u32;
+
+        let leader: &SymbolLayer_Impl =
+            to_symbol_layer_properties(layers.first().unwrap()).layer_impl();
+
+        let mut self_ = Self {
+            bucket_leader_id: layers.first().unwrap().base_impl().id.clone(),
+
+            source_layer,
+            overscaling,
+            zoom,
+            canonical_id: parameters.tile_id.canonical,
+            mode: parameters.mode,
+            pixel_ratio: parameters.pixel_ratio,
+            tile_size: tile_size,
+            tile_pixel_ratio: EXTENT / tile_size as f64,
+            layout: create_layout(
+                &to_symbol_layer_properties(layers.first().unwrap())
+                    .layer_impl()
+                    .layout,
+                zoom,
+            ),
+            text_size: leader.layout.get_dynamic::<TextSize>(),
+            icon_size: leader.layout.get_dynamic::<IconSize>(),
+            text_radial_offset: leader.layout.get_dynamic::<TextRadialOffset>(),
+
+            // default values
+            layer_paint_properties: Default::default(),
+            symbol_instances: vec![],
+            sort_key_ranges: vec![],
+            icons_need_linear: false,
+            sort_features_by_y: false,
+            sort_features_by_key: false,
+            allow_vertical_placement: false,
+            icons_in_text: false,
+            placement_modes: vec![],
+            features: vec![],
+            bidi: BiDi,
+            compare_text: Default::default(),
+        };
+
+        let has_text = self_.layout.has::<TextField>() && self_.layout.has::<TextFont>();
+        let has_icon = self_.layout.has::<IconImage>();
+
+        if !has_text && !has_icon {
+            return None;
+        }
+
+        let has_symbol_sort_key = !leader.layout.get_dynamic::<SymbolSortKey>().is_undefined();
+        let symbol_zorder = self_.layout.get::<SymbolZOrder>();
+        self_.sort_features_by_key =
+            symbol_zorder != SymbolZOrderType::ViewportY && has_symbol_sort_key;
+        let z_order_by_viewport_y = symbol_zorder == SymbolZOrderType::ViewportY
+            || (symbol_zorder == SymbolZOrderType::Auto && !self_.sort_features_by_key);
+        self_.sort_features_by_y = z_order_by_viewport_y
+            && (self_.layout.get::<TextAllowOverlap>()
+                || self_.layout.get::<IconAllowOverlap>()
+                || self_.layout.get::<TextIgnorePlacement>()
+                || self_.layout.get::<IconIgnorePlacement>());
+        if self_.layout.get::<SymbolPlacement>() == SymbolPlacementType::Point {
+            let mut modes = self_.layout.get::<TextWritingMode>();
+
+            // Remove duplicates and preserve order.
+            // TODO Verify if this is correct. Maybe make this better.
+            let mut seen: BTreeSet<TextWritingModeType> = BTreeSet::new();
+            modes = modes
+                .iter()
+                .filter(|placement_mode| {
+                    self_.allow_vertical_placement = self_.allow_vertical_placement
+                        || **placement_mode == TextWritingModeType::Vertical;
+                    seen.insert(**placement_mode)
+                })
+                .cloned()
+                .collect();
+
+            self_.placement_modes = modes;
+        }
+
+        for layer in layers {
+            self_
+                .layer_paint_properties
+                .insert(layer.base_impl().id.clone(), layer.clone());
+        }
+
+        // Determine glyph dependencies
+        let feature_count = self_.source_layer.feature_count();
+        for i in 0..feature_count {
+            let feature = self_.source_layer.get_feature(i);
+
+            // TODO
+            //if (!leader.filter(expression::EvaluationContext::new(self_.zoom, feature.get()).withCanonicalTileID(&parameters.tileID.canonical), )) {
+            //    continue;
+            //}
+
+            let mut ft: SymbolGeometryTileFeature = *feature.clone();
+
+            ft.index = i;
+
+            if has_text {
+                let formatted = self_.layout.evaluate4::<TextField>(
+                    self_.zoom,
+                    &ft,
+                    layout_parameters.available_images,
+                    self_.canonical_id,
+                );
+                let text_transform =
+                    self_
+                        .layout
+                        .evaluate::<TextTransform>(self_.zoom, &ft, self_.canonical_id);
+                let base_font_stack =
+                    self_
+                        .layout
+                        .evaluate::<TextFont>(self_.zoom, &ft, self_.canonical_id);
+
+                ft.formatted_text = Some(TaggedString::default());
+                let ft_formatted_text = ft.formatted_text.as_mut().unwrap();
+                for section in &formatted.sections {
+                    if let Some(image) = &section.image {
+                        layout_parameters
+                            .image_dependencies
+                            .insert(image.image_id.clone(), ImageType::Icon);
+                        ft_formatted_text.add_image_section(image.image_id.clone());
+                    } else {
+                        let mut u8string = section.text.clone();
+                        if text_transform == TextTransformType::Uppercase {
+                            u8string = u8string.to_uppercase();
+                        } else if text_transform == TextTransformType::Lowercase {
+                            u8string = u8string.to_lowercase();
+                        }
+
+                        // TODO seems like invalid UTF-8 can not be in a tile? if let Err(e) =
+                        ft_formatted_text.add_text_section(
+                            &apply_arabic_shaping(&U16String::from(u8string.as_str())),
+                            if let Some(font_scale) = section.font_scale {
+                                font_scale
+                            } else {
+                                1.0
+                            },
+                            if let Some(font_stack) = &section.font_stack {
+                                font_stack.clone()
+                            } else {
+                                base_font_stack.clone()
+                            },
+                            section.text_color.clone(),
+                        )
+                        //{
+                        //    log::error!("Encountered section with invalid UTF-8 in tile, source: {} z: {} x: {} y: {}", self_.sourceLayer.getName(), self_.canonicalID.z, self_.canonicalID.x, self_.canonicalID.y);
+                        //    continue; // skip section
+                        //}
+                    }
+                }
+
+                let can_verticalize_text = self_.layout.get::<TextRotationAlignment>()
+                    == AlignmentType::Map
+                    && self_.layout.get::<SymbolPlacement>() != SymbolPlacementType::Point
+                    && ft_formatted_text.allows_vertical_writing_mode();
+
+                // Loop through all characters of this text and collect unique codepoints.
+                for j in 0..ft_formatted_text.length() {
+                    let section =
+                        &formatted.sections[ft_formatted_text.get_section_index(j) as usize];
+                    if section.image.is_some() {
+                        continue;
+                    }
+
+                    let section_font_stack = &section.font_stack;
+                    let dependencies: &mut GlyphIDs = layout_parameters
+                        .glyph_dependencies
+                        .entry(if let Some(section_font_stack) = section_font_stack {
+                            section_font_stack.clone()
+                        } else {
+                            base_font_stack.clone()
+                        })
+                        .or_default(); // TODO this is different in C++, as C++ always creates the default apparently
+                    let code_point: Char16 = ft_formatted_text.get_char_code_at(j);
+                    dependencies.insert(code_point);
+                    if can_verticalize_text
+                        || (self_.allow_vertical_placement
+                            && ft_formatted_text.allows_vertical_writing_mode())
+                    {
+                        let vertical_chr: Char16 = i18n::verticalize_punctuation(code_point);
+                        if vertical_chr != 0 {
+                            dependencies.insert(vertical_chr);
+                        }
+                    }
+                }
+            }
+
+            if has_icon {
+                ft.icon = Some(self_.layout.evaluate4::<IconImage>(
+                    self_.zoom,
+                    &ft,
+                    layout_parameters.available_images,
+                    self_.canonical_id,
+                )); // TODO it might be that this is None?
+                layout_parameters
+                    .image_dependencies
+                    .insert(ft.icon.as_ref().unwrap().image_id.clone(), ImageType::Icon);
+            }
+
+            if ft.formatted_text.is_some() || ft.icon.is_some() {
+                if self_.sort_features_by_key {
+                    ft.sort_key =
+                        self_
+                            .layout
+                            .evaluate::<SymbolSortKey>(self_.zoom, &ft, self_.canonical_id);
+
+                    let lower_bound = lower_bound(&self_.features, &ft);
+                    self_.features.insert(lower_bound, ft);
+                } else {
+                    self_.features.push(ft);
+                }
+            }
+        }
+
+        if self_.layout.get::<SymbolPlacement>() == SymbolPlacementType::Line {
+            todo!()
+            // TODO mergeLines(self_.features);
+        }
+
+        Some(self_)
+    }
+    /// maplibre/maplibre-native#4add9ea original name: prepareSymbols
+    pub fn prepare_symbols(
+        &mut self,
+        glyph_map: &GlyphMap,
+        glyph_positions: &GlyphPositions,
+        image_map: &ImageMap,
+        image_positions: &ImagePositions,
+    ) {
+        let is_point_placement: bool =
+            self.layout.get::<SymbolPlacement>() == SymbolPlacementType::Point;
+        let text_along_line: bool =
+            self.layout.get::<TextRotationAlignment>() == AlignmentType::Map && !is_point_placement;
+
+        let mut to_process_features = Vec::new();
+
+        for (feature_index, feature) in self.features.iter_mut().enumerate() {
+            // TODO expensive clone
+            if feature.geometry.is_empty() {
+                continue;
+            }
+
+            let mut shaped_text_orientations: ShapedTextOrientations =
+                ShapedTextOrientations::default();
+            let mut shaped_icon: Option<PositionedIcon> = None;
+            let mut text_offset = [0.0, 0.0];
+            let layout_text_size: f64 =
+                self.layout
+                    .evaluate::<TextSize>(self.zoom + 1., feature, self.canonical_id);
+            let layout_text_size_at_bucket_zoom_level: f64 =
+                self.layout
+                    .evaluate::<TextSize>(self.zoom, feature, self.canonical_id);
+            let layout_icon_size: f64 =
+                self.layout
+                    .evaluate::<IconSize>(self.zoom + 1., feature, self.canonical_id);
+
+            // if feature has text, shape the text
+            if let Some(mut feature_formatted_text) = feature.formatted_text.clone() {
+                if layout_text_size > 0.0 {
+                    let line_height: f64 = self.layout.get::<TextLineHeight>() * ONE_EM;
+                    let spacing: f64 =
+                        if i18n::allows_letter_spacing(feature_formatted_text.raw_text()) {
+                            self.layout.evaluate::<TextLetterSpacing>(
+                                self.zoom,
+                                feature,
+                                self.canonical_id,
+                            ) * ONE_EM
+                        } else {
+                            0.0
+                        };
+
+                    let apply_shaping = |formatted_text: &TaggedString,
+                                         writing_mode: WritingModeType,
+                                         text_anchor: SymbolAnchorType,
+                                         text_justify: TextJustifyType,
+                                         text_offset: &[f64; 2]|
+                     -> Shaping {
+                        get_shaping(
+                            /* string */ formatted_text,
+                            /* maxWidth: ems */
+                            if is_point_placement {
+                                self.layout.evaluate::<TextMaxWidth>(
+                                    self.zoom,
+                                    feature,
+                                    self.canonical_id,
+                                ) * ONE_EM
+                            } else {
+                                0.0
+                            },
+                            /* ems */ line_height,
+                            text_anchor,
+                            text_justify,
+                            /* ems */ spacing,
+                            /* translate */ text_offset,
+                            /* writingMode */ writing_mode,
+                            /* bidirectional algorithm object */ &self.bidi,
+                            glyph_map,
+                            /* glyphs */ glyph_positions,
+                            /* images */ image_positions,
+                            layout_text_size,
+                            layout_text_size_at_bucket_zoom_level,
+                            self.allow_vertical_placement,
+                        )
+                    };
+
+                    let variable_text_anchor: Vec<TextVariableAnchorType> =
+                        self.layout.evaluate_static::<TextVariableAnchor>(
+                            self.zoom,
+                            feature,
+                            self.canonical_id,
+                        );
+                    let text_anchor: SymbolAnchorType =
+                        self.layout
+                            .evaluate::<TextAnchor>(self.zoom, feature, self.canonical_id);
+                    if variable_text_anchor.is_empty() {
+                        // Layers with variable anchors use the `text-radial-offset`
+                        // property and the [x, y] offset vector is calculated at
+                        // placement time instead of layout time
+                        let radial_offset: f64 = self.layout.evaluate::<TextRadialOffset>(
+                            self.zoom,
+                            feature,
+                            self.canonical_id,
+                        );
+                        if radial_offset > 0.0 {
+                            // The style spec says don't use `text-offset` and
+                            // `text-radial-offset` together but doesn't actually
+                            // specify what happens if you use both. We go with the
+                            // radial offset.
+                            text_offset =
+                                evaluate_radial_offset(text_anchor, radial_offset * ONE_EM);
+                        } else {
+                            text_offset = [
+                                self.layout.evaluate::<TextOffset>(
+                                    self.zoom,
+                                    feature,
+                                    self.canonical_id,
+                                )[0] * ONE_EM,
+                                self.layout.evaluate::<TextOffset>(
+                                    self.zoom,
+                                    feature,
+                                    self.canonical_id,
+                                )[1] * ONE_EM,
+                            ];
+                        }
+                    }
+                    let mut text_justify = if text_along_line {
+                        TextJustifyType::Center
+                    } else {
+                        self.layout
+                            .evaluate::<TextJustify>(self.zoom, feature, self.canonical_id)
+                    };
+
+                    let add_vertical_shaping_for_point_label_if_needed =
+                        |shaped_text_orientations: &mut ShapedTextOrientations,
+                         feature_formatted_text: &mut TaggedString| {
+                            if self.allow_vertical_placement
+                                && feature_formatted_text.allows_vertical_writing_mode()
+                            {
+                                feature_formatted_text.verticalize_punctuation();
+                                // Vertical POI label placement is meant to be used for
+                                // scripts that support vertical writing mode, thus, default
+                                // TextJustifyType::Left justification is used. If
+                                // Latin scripts would need to be supported, this should
+                                // take into account other justifications.
+                                shaped_text_orientations.set_vertical(apply_shaping(
+                                    feature_formatted_text,
+                                    WritingModeType::Vertical,
+                                    text_anchor,
+                                    TextJustifyType::Left,
+                                    &text_offset,
+                                ))
+                            }
+                        };
+
+                    // If this layer uses text-variable-anchor, generate shapings for
+                    // all justification possibilities.
+                    if !text_along_line && !variable_text_anchor.is_empty() {
+                        let mut justifications: Vec<TextJustifyType> = Vec::new();
+                        if text_justify != TextJustifyType::Auto {
+                            justifications.push(text_justify);
+                        } else {
+                            for anchor in &variable_text_anchor {
+                                justifications.push(get_anchor_justification(anchor));
+                            }
+                        }
+                        for justification in justifications {
+                            let mut shaping_for_justification = shaping_for_text_justify_type(
+                                &shaped_text_orientations,
+                                justification,
+                            );
+                            if shaping_for_justification.is_any_line_not_empty() {
+                                continue;
+                            }
+                            // If using text-variable-anchor for the layer, we use a
+                            // center anchor for all shapings and apply the offsets for
+                            // the anchor in the placement step.
+                            let shaping = apply_shaping(
+                                &feature_formatted_text,
+                                WritingModeType::Horizontal,
+                                SymbolAnchorType::Center,
+                                justification,
+                                &text_offset,
+                            );
+                            if shaping.is_any_line_not_empty() {
+                                shaping_for_justification = &shaping;
+                                if shaping_for_justification.positioned_lines.len() == 1 {
+                                    shaped_text_orientations.single_line = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        // Vertical point label shaping if allowVerticalPlacement is enabled.
+                        add_vertical_shaping_for_point_label_if_needed(
+                            &mut shaped_text_orientations,
+                            &mut feature_formatted_text,
+                        );
+                    } else {
+                        if text_justify == TextJustifyType::Auto {
+                            text_justify = get_anchor_justification(&text_anchor);
+                        }
+
+                        // Horizontal point or line label.
+                        let shaping = apply_shaping(
+                            &feature_formatted_text,
+                            WritingModeType::Horizontal,
+                            text_anchor,
+                            text_justify,
+                            &text_offset,
+                        );
+                        if shaping.is_any_line_not_empty() {
+                            shaped_text_orientations.set_horizontal(shaping)
+                        }
+
+                        // Vertical point label shaping if allowVerticalPlacement is enabled.
+                        add_vertical_shaping_for_point_label_if_needed(
+                            &mut shaped_text_orientations,
+                            &mut feature_formatted_text,
+                        );
+
+                        // Verticalized line label.
+                        if text_along_line && feature_formatted_text.allows_vertical_writing_mode()
+                        {
+                            feature_formatted_text.verticalize_punctuation();
+                            shaped_text_orientations.set_vertical(apply_shaping(
+                                &feature_formatted_text,
+                                WritingModeType::Vertical,
+                                text_anchor,
+                                text_justify,
+                                &text_offset,
+                            ));
+                        }
+                    }
+                }
+
+                feature.formatted_text = Some(feature_formatted_text);
+            }
+
+            // if feature has icon, get sprite atlas position
+            let mut icon_type: SymbolContent = SymbolContent::None;
+            if let Some(icon) = &feature.icon {
+                let image = image_map.get(&icon.image_id);
+                if let Some(image) = image {
+                    icon_type = SymbolContent::IconRGBA;
+                    shaped_icon = Some(PositionedIcon::shape_icon(
+                        image_positions.get(&icon.image_id).unwrap().clone(),
+                        &self
+                            .layout
+                            .evaluate::<IconOffset>(self.zoom, feature, self.canonical_id),
+                        self.layout
+                            .evaluate::<IconAnchor>(self.zoom, feature, self.canonical_id),
+                    ));
+                    if image.sdf {
+                        icon_type = SymbolContent::IconSDF;
+                    }
+                    if image.pixel_ratio != self.pixel_ratio {
+                        self.icons_need_linear = true;
+                    } else if self.layout.get_dynamic::<IconRotate>().constant_or(1.0) != 0.0 {
+                        self.icons_need_linear = true;
+                    }
+                }
+            }
+
+            // if either shapedText or icon position is present, add the feature
+            let default_shaping = get_default_horizontal_shaping(&shaped_text_orientations);
+            self.icons_in_text = if default_shaping.is_any_line_not_empty() {
+                default_shaping.icons_in_text
+            } else {
+                false
+            };
+            if default_shaping.is_any_line_not_empty() || shaped_icon.is_some() {
+                // TODO borrow conflict with self.features
+                to_process_features.push((
+                    feature_index,
+                    shaped_text_orientations,
+                    shaped_icon,
+                    image_map,
+                    text_offset,
+                    layout_text_size,
+                    layout_icon_size,
+                    icon_type,
+                ));
+            }
+        }
+
+        for (
+            feature_index,
+            shaped_text_orientations,
+            shaped_icon,
+            imageMap,
+            text_offset,
+            layout_text_size,
+            layout_icon_size,
+            icon_type,
+        ) in to_process_features
+        {
+            self.add_feature(
+                feature_index,
+                &self.features[feature_index].clone(), // TODO likely wrong clone
+                &shaped_text_orientations,
+                shaped_icon,
+                imageMap,
+                text_offset,
+                layout_text_size,
+                layout_icon_size,
+                icon_type,
+            );
+
+            self.features[feature_index].geometry.clear();
+        }
+
+        self.compare_text.clear();
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: createBucket
+    pub fn create_bucket(
+        &self,
+        _image_positions: ImagePositions,
+        _feature_index: Box<FeatureIndex>,
+        render_data: &mut HashMap<String, LayerRenderData>,
+        first_load: bool,
+        show_collision_boxes: bool,
+        canonical: &CanonicalTileID,
+    ) {
+        let mut symbol_instances = self.symbol_instances.clone(); // TODO should we clone or modify the symbol instances?
+        let mut bucket: SymbolBucket = SymbolBucket::new(
+            self.layout.clone(),
+            &self.layer_paint_properties,
+            &self.text_size,
+            &self.icon_size,
+            self.zoom,
+            self.icons_need_linear,
+            self.sort_features_by_y,
+            self.bucket_leader_id.clone(),
+            self.symbol_instances.clone(), // TODO should we clone or modify the symbol instances?
+            self.sort_key_ranges.clone(),
+            self.tile_pixel_ratio,
+            self.allow_vertical_placement,
+            self.placement_modes.clone(),
+            self.icons_in_text,
+        );
+
+        for symbol_instance in &mut symbol_instances {
+            let has_text = symbol_instance.has_text();
+            let has_icon = symbol_instance.has_icon();
+            let single_line = symbol_instance.single_line;
+
+            let feature = self
+                .features
+                .get(symbol_instance.layout_feature_index)
+                .unwrap();
+
+            // Insert final placement into collision tree and add glyphs/icons to buffers
+
+            // Process icon first, so that text symbols would have reference to
+            // iconIndex which is used when dynamic vertices for icon-text-fit image
+            // have to be updated.
+            if has_icon {
+                let size_data: Range<f64> = bucket.icon_size_binder.get_vertex_size_data(feature); // TODO verify usage of range
+                let icon_buffer = if symbol_instance.has_sdf_icon() {
+                    &mut bucket.sdf_icon
+                } else {
+                    &mut bucket.icon
+                };
+                let mut place_icon =
+                    |icon_quads: &SymbolQuads, mut index: usize, writing_mode: WritingModeType| {
+                        let mut icon_symbol = PlacedSymbol {
+                            anchor_point: symbol_instance.anchor.point,
+                            segment: symbol_instance.anchor.segment.unwrap_or(0),
+                            lower_size: size_data.start,
+                            upper_size: size_data.end,
+                            line_offset: symbol_instance.icon_offset,
+                            writing_modes: writing_mode,
+                            line: symbol_instance.line().clone(),
+                            tile_distances: Vec::new(),
+                            glyph_offsets: vec![],
+                            hidden: false,
+                            vertex_start_index: 0,
+                            cross_tile_id: 0,
+                            placed_orientation: None,
+                            angle: if self.allow_vertical_placement
+                                && writing_mode == WritingModeType::Vertical
+                            {
+                                PI / 2.
+                            } else {
+                                0.0
+                            },
+                            placed_icon_index: None,
+                        };
+
+                        icon_symbol.vertex_start_index = self.add_symbols(
+                            icon_buffer,
+                            size_data.clone(),
+                            icon_quads,
+                            &symbol_instance.anchor,
+                            &mut icon_symbol,
+                            feature.sort_key,
+                        );
+
+                        icon_buffer.placed_symbols.push(icon_symbol);
+                        index = icon_buffer.placed_symbols.len() - 1; // TODO we receive an index but always overwrite it
+                    };
+
+                place_icon(
+                    symbol_instance.icon_quads().as_ref().unwrap(),
+                    symbol_instance.placed_icon_index.unwrap(),
+                    WritingModeType::None,
+                );
+                if let Some(vertical_icon_quads) = symbol_instance.vertical_icon_quads() {
+                    place_icon(
+                        vertical_icon_quads,
+                        symbol_instance.placed_vertical_icon_index.unwrap(),
+                        WritingModeType::Vertical,
+                    );
+                }
+
+                // TODO
+                assert!(bucket.paint_properties.is_empty())
+                //for pair in bucket.paintProperties {
+                //    pair.1.iconBinders.populateVertexVectors(
+                //        feature,
+                //        iconBuffer.sharedVertices.elements(),
+                //        symbolInstance.dataFeatureIndex,
+                //        {},
+                //        {},
+                //        canonical,
+                //    );
+                //}
+            }
+
+            if has_text && feature.formatted_text.is_some() {
+                let mut last_added_section: Option<usize> = None;
+                if single_line {
+                    let mut placed_text_index: Option<usize> = None;
+                    let (new_last_added_section, new_placed_index) = self.add_symbol_glyph_quads(
+                        &mut bucket,
+                        symbol_instance,
+                        feature,
+                        symbol_instance.writing_modes,
+                        placed_text_index,
+                        symbol_instance.right_justified_glyph_quads(),
+                        canonical,
+                        last_added_section,
+                    );
+                    last_added_section = Some(new_last_added_section);
+                    placed_text_index = new_placed_index;
+                    symbol_instance.placed_right_text_index = placed_text_index;
+                    symbol_instance.placed_center_text_index = placed_text_index;
+                    symbol_instance.placed_left_text_index = placed_text_index;
+                } else {
+                    if symbol_instance.right_justified_glyph_quads_size != 0 {
+                        let (new_last_added_section, new_placed_index) = self
+                            .add_symbol_glyph_quads(
+                                &mut bucket,
+                                symbol_instance,
+                                feature,
+                                symbol_instance.writing_modes,
+                                symbol_instance.placed_right_text_index,
+                                symbol_instance.right_justified_glyph_quads(),
+                                canonical,
+                                last_added_section,
+                            );
+                        last_added_section = Some(new_last_added_section);
+                        symbol_instance.placed_right_text_index = new_placed_index
+                    }
+                    if symbol_instance.center_justified_glyph_quads_size != 0 {
+                        let (new_last_added_section, new_placed_index) = self
+                            .add_symbol_glyph_quads(
+                                &mut bucket,
+                                symbol_instance,
+                                feature,
+                                symbol_instance.writing_modes,
+                                symbol_instance.placed_center_text_index,
+                                symbol_instance.center_justified_glyph_quads(),
+                                canonical,
+                                last_added_section,
+                            );
+                        last_added_section = Some(new_last_added_section);
+                        symbol_instance.placed_center_text_index = new_placed_index
+                    }
+                    if symbol_instance.left_justified_glyph_quads_size != 0 {
+                        let (new_last_added_section, new_placed_index) = self
+                            .add_symbol_glyph_quads(
+                                &mut bucket,
+                                symbol_instance,
+                                feature,
+                                symbol_instance.writing_modes,
+                                symbol_instance.placed_left_text_index,
+                                symbol_instance.left_justified_glyph_quads(),
+                                canonical,
+                                last_added_section,
+                            );
+                        last_added_section = Some(new_last_added_section);
+                        symbol_instance.placed_left_text_index = new_placed_index
+                    }
+                }
+                if symbol_instance.writing_modes.contains(WritingModeType::Vertical) // TODO is bitset op correct?
+                    && symbol_instance.vertical_glyph_quads_size != 0
+                {
+                    let (new_last_added_section, new_placed_index) = self.add_symbol_glyph_quads(
+                        &mut bucket,
+                        symbol_instance,
+                        feature,
+                        WritingModeType::Vertical,
+                        symbol_instance.placed_vertical_text_index,
+                        symbol_instance.vertical_glyph_quads(),
+                        canonical,
+                        last_added_section,
+                    );
+                    last_added_section = Some(new_last_added_section);
+                    symbol_instance.placed_vertical_text_index = new_placed_index
+                }
+                assert!(last_added_section.is_some()); // True, as hasText == true;
+                self.update_paint_properties_for_section(
+                    &mut bucket,
+                    feature,
+                    last_added_section.unwrap(),
+                    canonical,
+                );
+            }
+
+            symbol_instance.release_shared_data();
+        }
+
+        if show_collision_boxes {
+            self.add_to_debug_buffers(&mut bucket);
+        }
+        if bucket.has_data() {
+            for pair in &self.layer_paint_properties {
+                if !first_load {
+                    bucket.just_reloaded = true;
+                }
+                render_data.insert(
+                    pair.0.clone(),
+                    LayerRenderData {
+                        bucket: bucket.clone(), // TODO is cloning intended here?
+                        layer_properties: pair.1.clone(),
+                    },
+                );
+            }
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: hasSymbolInstances
+    fn has_symbol_instances(&self) -> bool {
+        !self.symbol_instances.is_empty()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: hasDependencies
+    fn has_dependencies(&self) -> bool {
+        !self.features.is_empty()
+    }
+
+    pub const INVALID_OFFSET_VALUE: f64 = f64::MAX;
+    /**
+     * @brief Calculates variable text offset.
+     *
+     * @param anchor text anchor
+     * @param textOffset Either `text-offset` or [ `text-radial-offset`,
+     * INVALID_OFFSET_VALUE ]
+     * @return std::array<f64, 2> offset along x- and y- axis correspondingly.
+     */
+    /// maplibre/maplibre-native#4add9ea original name: evaluateVariableOffset
+    pub fn evaluate_variable_offset(anchor: SymbolAnchorType, mut offset: [f64; 2]) -> [f64; 2] {
+        if offset[1] == Self::INVALID_OFFSET_VALUE {
+            return evaluate_radial_offset(anchor, offset[0]);
+        }
+        let mut result = [0.0, 0.0];
+        offset[0] = (offset[0]).abs();
+        offset[1] = (offset[1]).abs();
+
+        match anchor {
+            SymbolAnchorType::TopRight | SymbolAnchorType::TopLeft | SymbolAnchorType::Top => {
+                result[1] = offset[1] - BASELINE_OFFSET;
+            }
+
+            SymbolAnchorType::BottomRight
+            | SymbolAnchorType::BottomLeft
+            | SymbolAnchorType::Bottom => {
+                result[1] = -offset[1] + BASELINE_OFFSET;
+            }
+
+            SymbolAnchorType::Center | SymbolAnchorType::Left | SymbolAnchorType::Right => {}
+        }
+
+        match anchor {
+            SymbolAnchorType::TopRight
+            | SymbolAnchorType::BottomRight
+            | SymbolAnchorType::Right => {
+                result[0] = -offset[0];
+            }
+            SymbolAnchorType::TopLeft | SymbolAnchorType::BottomLeft | SymbolAnchorType::Left => {
+                result[0] = offset[0];
+            }
+            SymbolAnchorType::Center | SymbolAnchorType::Top | SymbolAnchorType::Bottom => {}
+        }
+
+        result
+    }
+
+    // Analog of `addToLineVertexArray` in JS. This version doesn't need to build up
+    // a line array like the JS version does, but it uses the same logic to
+    // calculate tile distances.
+    /// maplibre/maplibre-native#4add9ea original name: calculateTileDistances
+    pub fn calculate_tile_distances(line: &GeometryCoordinates, anchor: &Anchor) -> Vec<f64> {
+        let mut tile_distances: Vec<f64> = vec![0.0; line.len()];
+        if let Some(segment) = anchor.segment {
+            assert!(segment < line.len());
+            let mut sum_forward_length = if segment + 1 < line.len() {
+                anchor.point.distance_to(line[segment + 1].cast::<f64>())
+            } else {
+                0.0
+            };
+            let mut sum_backward_length = anchor.point.distance_to(line[segment].cast::<f64>());
+            for i in segment + 1..line.len() {
+                tile_distances[i] = sum_forward_length;
+                if i < line.len() - 1 {
+                    sum_forward_length +=
+                        line[i + 1].cast::<f64>().distance_to(line[i].cast::<f64>());
+                }
+            }
+
+            let mut i = segment;
+            loop {
+                tile_distances[i] = sum_backward_length;
+                if i != 0 {
+                    sum_backward_length +=
+                        line[i - 1].cast::<f64>().distance_to(line[i].cast::<f64>());
+                } else {
+                    break; // Add break to avoid unsigned integer overflow when i==0
+                }
+                i -= 1;
+            }
+        }
+        tile_distances
+    }
+}
+
+impl SymbolLayout {
+    /// maplibre/maplibre-native#4add9ea original name: addFeature
+    fn add_feature(
+        &mut self,
+        layout_feature_index: usize,
+        feature: &SymbolGeometryTileFeature,
+        shaped_text_orientations: &ShapedTextOrientations,
+        mut shaped_icon: Option<PositionedIcon>, // TODO should this be an output?
+        image_map: &ImageMap,
+        text_offset: [f64; 2],
+        layout_text_size: f64,
+        layout_icon_size: f64,
+        icon_type: SymbolContent,
+    ) {
+        let min_scale = 0.5;
+        let glyph_size = 24.0;
+
+        let icon_offset: [f64; 2] =
+            self.layout
+                .evaluate::<IconOffset>(self.zoom, feature, self.canonical_id);
+
+        // To reduce the number of labels that jump around when zooming we need
+        // to use a text-size value that is the same for all zoom levels.
+        // This calculates text-size at a high zoom level so that all tiles can
+        // use the same value when calculating anchor positions.
+        let text_max_size = self
+            .layout
+            .evaluate::<TextSize>(18., feature, self.canonical_id);
+
+        let font_scale = layout_text_size / glyph_size;
+        let text_box_scale = self.tile_pixel_ratio * font_scale;
+        let text_max_box_scale = self.tile_pixel_ratio * text_max_size / glyph_size;
+        let icon_box_scale = self.tile_pixel_ratio * layout_icon_size;
+        let symbol_spacing = self.tile_pixel_ratio * self.layout.get::<SymbolSpacing>();
+        let text_padding = self.layout.get::<TextPadding>() * self.tile_pixel_ratio;
+        let icon_padding = self.layout.get::<IconPadding>() * self.tile_pixel_ratio;
+        let text_max_angle = deg2radf(self.layout.get::<TextMaxAngle>());
+        let icon_rotation =
+            self.layout
+                .evaluate::<IconRotate>(self.zoom, feature, self.canonical_id);
+        let text_rotation =
+            self.layout
+                .evaluate::<TextRotate>(self.zoom, feature, self.canonical_id);
+        let variable_text_offset: [f64; 2];
+        if !self.text_radial_offset.is_undefined() {
+            variable_text_offset = [
+                self.layout
+                    .evaluate::<TextRadialOffset>(self.zoom, feature, self.canonical_id)
+                    * ONE_EM,
+                Self::INVALID_OFFSET_VALUE,
+            ];
+        } else {
+            variable_text_offset = [
+                self.layout
+                    .evaluate::<TextOffset>(self.zoom, feature, self.canonical_id)[0]
+                    * ONE_EM,
+                self.layout
+                    .evaluate::<TextOffset>(self.zoom, feature, self.canonical_id)[1]
+                    * ONE_EM,
+            ];
+        }
+
+        let text_placement: SymbolPlacementType =
+            if self.layout.get::<TextRotationAlignment>() != AlignmentType::Map {
+                SymbolPlacementType::Point
+            } else {
+                self.layout.get::<SymbolPlacement>()
+            };
+
+        let text_repeat_distance: f64 = symbol_spacing / 2.;
+        let evaluated_layout_properties: SymbolLayoutProperties_Evaluated =
+            self.layout.evaluate_feature(self.zoom, feature);
+        let indexed_feature = IndexedSubfeature {
+            ref_: RefIndexedSubfeature {
+                index: feature.index,
+                sort_index: self.symbol_instances.len(),
+                source_layer_name: self.source_layer.get_name().to_string(),
+                bucket_leader_id: self.bucket_leader_id.clone(),
+                bucket_instance_id: 0,
+                collision_group_id: 0,
+            },
+            source_layer_name_copy: self.source_layer.get_name().to_string(),
+            bucket_leader_idcopy: self.bucket_leader_id.clone(),
+        };
+
+        let icon_text_fit = evaluated_layout_properties.get::<IconTextFit>();
+        let has_icon_text_fit = icon_text_fit != IconTextFitType::None;
+        // Adjust shaped icon size when icon-text-fit is used.
+        let mut vertically_shaped_icon: Option<PositionedIcon> = None;
+
+        if let Some(shaped_icon) = &mut shaped_icon {
+            if has_icon_text_fit {
+                // Create vertically shaped icon for vertical writing mode if needed.
+                if self.allow_vertical_placement
+                    && shaped_text_orientations.vertical().is_any_line_not_empty()
+                {
+                    vertically_shaped_icon = Some(shaped_icon.clone());
+                    vertically_shaped_icon.as_mut().unwrap().fit_icon_to_text(
+                        shaped_text_orientations.vertical(),
+                        icon_text_fit,
+                        &self.layout.get::<IconTextFitPadding>(),
+                        &icon_offset,
+                        font_scale,
+                    );
+                }
+                let shaped_text = get_default_horizontal_shaping(shaped_text_orientations);
+                if shaped_text.is_any_line_not_empty() {
+                    shaped_icon.fit_icon_to_text(
+                        shaped_text,
+                        icon_text_fit,
+                        &self.layout.get::<IconTextFitPadding>(),
+                        &icon_offset,
+                        font_scale,
+                    );
+                }
+            }
+        }
+
+        let mut add_symbol_instance =
+            |anchor: &Anchor, shared_data: Rc<SymbolInstanceSharedData>| {
+                // assert!(sharedData); TODO
+                let anchor_inside_tile = anchor.point.x >= 0.
+                    && anchor.point.x < EXTENT
+                    && anchor.point.y >= 0.
+                    && anchor.point.y < EXTENT;
+
+                if self.mode == MapMode::Tile || anchor_inside_tile {
+                    // For static/continuous rendering, only add symbols anchored within this tile:
+                    //  neighboring symbols will be added as part of the neighboring tiles.
+                    // In tiled rendering mode, add all symbols in the buffers so that we can:
+                    //  (1) render symbols that overlap into this tile
+                    //  (2) approximate collision detection effects from neighboring symbols
+                    self.symbol_instances.push(SymbolInstance::new(
+                        *anchor,
+                        shared_data,
+                        shaped_text_orientations,
+                        &shaped_icon,
+                        &vertically_shaped_icon,
+                        text_box_scale,
+                        text_padding,
+                        text_placement,
+                        text_offset,
+                        icon_box_scale,
+                        icon_padding,
+                        icon_offset,
+                        indexed_feature.clone(),
+                        layout_feature_index,
+                        feature.index,
+                        if let Some(formatted_text) = &feature.formatted_text {
+                            formatted_text.raw_text().clone()
+                        } else {
+                            U16String::new()
+                        },
+                        self.overscaling,
+                        icon_rotation,
+                        text_rotation,
+                        variable_text_offset,
+                        self.allow_vertical_placement,
+                        icon_type,
+                    ));
+
+                    if self.sort_features_by_key {
+                        if !self.sort_key_ranges.is_empty()
+                            && self.sort_key_ranges.last().unwrap().sort_key == feature.sort_key
+                        {
+                            self.sort_key_ranges.last_mut().unwrap().end =
+                                self.symbol_instances.len();
+                        } else {
+                            self.sort_key_ranges.push(SortKeyRange {
+                                sort_key: feature.sort_key,
+                                start: self.symbol_instances.len() - 1,
+                                end: self.symbol_instances.len(),
+                            });
+                        }
+                    }
+                }
+            };
+
+        let create_symbol_instance_shared_data = |line: GeometryCoordinates| {
+            Rc::new(SymbolInstanceSharedData::new(
+                line,
+                shaped_text_orientations,
+                shaped_icon.clone(),
+                vertically_shaped_icon.clone(),
+                &evaluated_layout_properties,
+                text_placement,
+                text_offset,
+                image_map,
+                icon_rotation,
+                icon_type,
+                has_icon_text_fit,
+                self.allow_vertical_placement,
+            ))
+        };
+
+        let type_ = feature.get_type();
+
+        if self.layout.get::<SymbolPlacement>() == SymbolPlacementType::Line {
+            todo!()
+            /*let clippedLines = clipLines(feature.geometry, 0, 0, EXTENT, EXTENT);
+            for line in clippedLines {
+                let anchors: Anchors = getAnchors(
+                    line,
+                    symbolSpacing,
+                    textMaxAngle,
+                    (if shapedTextOrientations.vertical {
+                        &shapedTextOrientations.vertical
+                    } else {
+                        getDefaultHorizontalShaping(shapedTextOrientations)
+                    })
+                    .left,
+                    (if shapedTextOrientations.vertical {
+                        &shapedTextOrientations.vertical
+                    } else {
+                        getDefaultHorizontalShaping(shapedTextOrientations)
+                    })
+                    .right,
+                    (if shapedIcon { shapedIcon.left() } else { 0 }),
+                    (if shapedIcon { shapedIcon.right() } else { 0 }),
+                    glyphSize,
+                    textMaxBoxScale,
+                    self.overscaling,
+                );
+                let sharedData = createSymbolInstanceSharedData(line);
+                for anchor in anchors {
+                    if (!feature.formattedText
+                        || !self.anchorIsTooClose(
+                            feature.formattedText.rawText(),
+                            textRepeatDistance,
+                            anchor,
+                        ))
+                    {
+                        addSymbolInstance(anchor, sharedData);
+                    }
+                }
+            }*/
+        } else if self.layout.get::<SymbolPlacement>() == SymbolPlacementType::LineCenter {
+            todo!()
+            /*
+            // No clipping, multiple lines per feature are allowed
+            // "lines" with only one point are ignored as in clipLines
+            for line in feature.geometry {
+                if (line.len() > 1) {
+                    let anchor: Option<Anchor> = getCenterAnchor(
+                        line,
+                        textMaxAngle,
+                        (if shapedTextOrientations.vertical {
+                            shapedTextOrientations.vertical
+                        } else {
+                            getDefaultHorizontalShaping(shapedTextOrientations)
+                        })
+                        .left,
+                        (if shapedTextOrientations.vertical {
+                            shapedTextOrientations.vertical
+                        } else {
+                            getDefaultHorizontalShaping(shapedTextOrientations)
+                        })
+                        .right,
+                        (if shapedIcon { shapedIcon.left() } else { 0 }),
+                        (if shapedIcon { shapedIcon.right() } else { 0 }),
+                        glyphSize,
+                        textMaxBoxScale,
+                    );
+                    if (anchor) {
+                        addSymbolInstance(*anchor, createSymbolInstanceSharedData(line));
+                    }
+                }
+            }*/
+        } else if type_ == FeatureType::Polygon {
+            todo!()
+            /*for polygon in classifyRings(feature.geometry) {
+                let poly: Polygon<f64>;
+                for ring in polygon {
+                    let r: LinearRing<f64>;
+                    for p in ring {
+                        r.push(convertPoint::<double>(p));
+                    }
+                    poly.push(r);
+                }
+
+                // 1 pixel worth of precision, in tile coordinates
+                let poi = mapbox::polylabel(poly, EXTENT / TILE_SIZE);
+                let anchor = Anchor::new((poi.x) as f64, (poi.y) as f64, 0.0, (minScale) as usize);
+                addSymbolInstance(anchor, createSymbolInstanceSharedData(polygon[0]));
+            }*/
+        } else if type_ == FeatureType::LineString {
+            for line in &feature.geometry {
+                // Skip invalid LineStrings.
+                if line.0.is_empty() {
+                    continue;
+                }
+
+                let anchor = Anchor {
+                    point: Point2D::new((line[0].x) as f64, (line[0].y) as f64),
+                    angle: 0.0,
+                    segment: Some((min_scale) as usize),
+                };
+                add_symbol_instance(&anchor, create_symbol_instance_shared_data(line.clone()));
+            }
+        } else if type_ == FeatureType::Point {
+            for points in &feature.geometry {
+                for point in &points.0 {
+                    let anchor = Anchor {
+                        point: Point2D::new((point.x) as f64, (point.y) as f64),
+                        angle: 0.0,
+                        segment: Some((min_scale) as usize),
+                    };
+                    add_symbol_instance(
+                        &anchor,
+                        create_symbol_instance_shared_data(GeometryCoordinates(vec![*point])),
+                    );
+                }
+            }
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: anchorIsTooClose
+    fn anchor_is_too_close(
+        &mut self,
+        text: &U16String,
+        repeat_distance: f64,
+        anchor: &Anchor,
+    ) -> bool {
+        if let Some(other_anchors) = self.compare_text.get(text) {
+            for other_anchor in other_anchors {
+                if anchor.point.distance_to(other_anchor.point) < repeat_distance {
+                    return true;
+                }
+            }
+        } else {
+            self.compare_text.insert(text.clone(), Anchors::new());
+        }
+
+        let anchors = self.compare_text.get_mut(text).unwrap();
+        anchors.push(*anchor);
+        false
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: addToDebugBuffers
+    fn add_to_debug_buffers(&self, bucket: &mut SymbolBucket) {
+        todo!()
+    }
+
+    // Adds placed items to the buffer.
+    /// maplibre/maplibre-native#4add9ea original name: addSymbol
+    fn add_symbol(
+        &self,
+        buffer: &mut SymbolBucketBuffer,
+        size_data: Range<f64>,
+        symbol: &SymbolQuad,
+        label_anchor: &Anchor,
+        sort_key: f64,
+    ) -> usize {
+        let vertex_length: u16 = 4;
+
+        let tl = symbol.tl;
+        let tr = symbol.tr;
+        let bl = symbol.bl;
+        let br = symbol.br;
+        let tex = symbol.tex;
+        let pixel_offset_tl = symbol.pixel_offset_tl;
+        let pixel_offset_br = symbol.pixel_offset_br;
+        let min_font_scale = symbol.min_font_scale;
+
+        if buffer.segments.is_empty()
+            || buffer.segments.last().unwrap().vertex_length + vertex_length as usize
+                > u16::MAX as usize
+            || (buffer.segments.last().unwrap().sort_key - sort_key).abs() > f64::EPSILON
+        {
+            buffer.segments.push(Segment {
+                vertex_offset: buffer.shared_vertices.len(),
+                index_offset: buffer.triangles.len(),
+                vertex_length: 0,
+                index_length: 0,
+                sort_key,
+                _phandom_data: Default::default(),
+            });
+        }
+
+        // We're generating triangle fans, so we always start with the first
+        // coordinate in this polygon.
+        let segment = buffer.segments.last_mut().unwrap();
+        assert!(segment.vertex_length <= u16::MAX as usize);
+        let index = (segment.vertex_length) as u16;
+
+        // coordinates (2 triangles)
+        let vertices = &mut buffer.shared_vertices;
+        vertices.push(SymbolVertex::new(
+            label_anchor.point,
+            tl,
+            symbol.glyph_offset.y,
+            tex.origin.x,
+            tex.origin.y,
+            size_data.clone(),
+            symbol.is_sdf,
+            pixel_offset_tl,
+            min_font_scale,
+        ));
+        vertices.push(SymbolVertex::new(
+            label_anchor.point,
+            tr,
+            symbol.glyph_offset.y,
+            tex.origin.x + tex.width(),
+            tex.origin.y,
+            size_data.clone(),
+            symbol.is_sdf,
+            Point2D::new(pixel_offset_br.x, pixel_offset_tl.y),
+            min_font_scale,
+        ));
+        vertices.push(SymbolVertex::new(
+            label_anchor.point,
+            bl,
+            symbol.glyph_offset.y,
+            tex.origin.x,
+            tex.origin.y + tex.height(),
+            size_data.clone(),
+            symbol.is_sdf,
+            Point2D::new(pixel_offset_tl.x, pixel_offset_br.y),
+            min_font_scale,
+        ));
+        vertices.push(SymbolVertex::new(
+            label_anchor.point,
+            br,
+            symbol.glyph_offset.y,
+            tex.origin.x + tex.width(),
+            tex.origin.y + tex.height(),
+            size_data.clone(),
+            symbol.is_sdf,
+            pixel_offset_br,
+            min_font_scale,
+        ));
+
+        // Dynamic/Opacity vertices are initialized so that the vertex count always
+        // agrees with the layout vertex buffer, but they will always be updated
+        // before rendering happens
+        let dynamic_vertex = DynamicVertex::new(label_anchor.point, 0.);
+        buffer.shared_dynamic_vertices.push(dynamic_vertex);
+        buffer.shared_dynamic_vertices.push(dynamic_vertex);
+        buffer.shared_dynamic_vertices.push(dynamic_vertex);
+        buffer.shared_dynamic_vertices.push(dynamic_vertex);
+
+        let opacity_vertex = OpacityVertex::new(true, 1.0);
+        buffer.shared_opacity_vertices.push(opacity_vertex);
+        buffer.shared_opacity_vertices.push(opacity_vertex);
+        buffer.shared_opacity_vertices.push(opacity_vertex);
+        buffer.shared_opacity_vertices.push(opacity_vertex);
+
+        // add the two triangles, referencing the four coordinates we just inserted.
+        buffer.triangles.push(index, index + 1, index + 2);
+        buffer.triangles.push(index + 1, index + 2, index + 3);
+
+        segment.vertex_length += vertex_length as usize;
+        segment.index_length += 6;
+
+        index as usize
+    }
+    /// maplibre/maplibre-native#4add9ea original name: addSymbols
+    fn add_symbols(
+        &self,
+        buffer: &mut SymbolBucketBuffer,
+        size_data: Range<f64>,
+        symbols: &SymbolQuads,
+        label_anchor: &Anchor,
+        placed_symbol: &mut PlacedSymbol,
+        sort_key: f64,
+    ) -> usize {
+        let mut first_symbol = true;
+        let mut first_index = 0;
+        for symbol in symbols {
+            let index = self.add_symbol(buffer, size_data.clone(), symbol, label_anchor, sort_key);
+            placed_symbol.glyph_offsets.push(symbol.glyph_offset.x);
+            if first_symbol {
+                first_index = index;
+                first_symbol = false;
+            }
+        }
+        first_index
+    }
+
+    // Adds symbol quads to bucket and returns formatted section index of last
+    // added quad.
+    /// maplibre/maplibre-native#4add9ea original name: addSymbolGlyphQuads
+    fn add_symbol_glyph_quads(
+        &self,
+        bucket: &mut SymbolBucket,
+        symbol_instance: &SymbolInstance,
+        feature: &SymbolGeometryTileFeature,
+        writing_mode: WritingModeType,
+        placed_index: Option<usize>, // TODO should this be an output?
+        glyph_quads: &SymbolQuads,
+        canonical: &CanonicalTileID,
+        mut last_added_section: Option<usize>, // TODO should this be an output?
+    ) -> (usize, Option<usize>) {
+        let mut output_placed_index = placed_index;
+        let size_data: Range<f64> = bucket.text_size_binder.get_vertex_size_data(feature); // TODO verify if usage of range is oke, empty ranges, reverse
+        let has_format_section_overrides: bool = bucket.has_format_section_overrides();
+        let placed_icon_index = if writing_mode == WritingModeType::Vertical {
+            symbol_instance.placed_vertical_icon_index
+        } else {
+            symbol_instance.placed_icon_index
+        };
+
+        // TODO is this PlacedSymbol correct?
+        let mut newly_placed_symbol = PlacedSymbol {
+            anchor_point: symbol_instance.anchor.point,
+            segment: symbol_instance.anchor.segment.unwrap_or(0),
+            lower_size: size_data.start,
+            upper_size: size_data.end,
+            line_offset: symbol_instance.text_offset,
+            writing_modes: writing_mode,
+            line: symbol_instance.line().clone(),
+            tile_distances: Self::calculate_tile_distances(
+                symbol_instance.line(),
+                &symbol_instance.anchor,
+            ),
+
+            glyph_offsets: vec![],
+            hidden: false,
+            vertex_start_index: 0,
+            cross_tile_id: 0,
+            placed_orientation: None,
+            angle: if self.allow_vertical_placement && writing_mode == WritingModeType::Vertical {
+                PI / 2.
+            } else {
+                0.0
+            },
+            placed_icon_index,
+        };
+
+        let mut first_symbol = true;
+        for symbol_quad in glyph_quads {
+            if has_format_section_overrides {
+                if let Some(last_added_section) = last_added_section {
+                    if last_added_section != symbol_quad.section_index {
+                        self.update_paint_properties_for_section(
+                            bucket,
+                            feature,
+                            last_added_section,
+                            canonical,
+                        );
+                    }
+                }
+
+                last_added_section = Some(symbol_quad.section_index);
+            }
+            let index = self.add_symbol(
+                &mut bucket.text,
+                size_data.clone(),
+                symbol_quad,
+                &symbol_instance.anchor,
+                feature.sort_key,
+            );
+
+            newly_placed_symbol
+                .glyph_offsets
+                .push(symbol_quad.glyph_offset.x);
+
+            if first_symbol {
+                newly_placed_symbol.vertex_start_index = index;
+                first_symbol = false;
+            }
+        }
+
+        bucket.text.placed_symbols.push(newly_placed_symbol);
+        output_placed_index = Some(bucket.text.placed_symbols.len() - 1);
+
+        if let Some(last_added_section) = last_added_section {
+            (last_added_section, output_placed_index)
+        } else {
+            (0, output_placed_index)
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: updatePaintPropertiesForSection
+    fn update_paint_properties_for_section(
+        &self,
+        bucket: &SymbolBucket,
+        feature: &SymbolGeometryTileFeature,
+        section_index: usize,
+        canonical: &CanonicalTileID,
+    ) -> usize {
+        let formatted_section = section_options_to_value(
+            feature
+                .formatted_text
+                .as_ref()
+                .unwrap()
+                .section_at(section_index),
+        );
+        // todo!()
+        // for pair in bucket.paintProperties {
+        //     pair.1.textBinders.populateVertexVectors(
+        //         feature,
+        //         bucket.text.vertices().elements(),
+        //         feature.index,
+        //         {},
+        //         {},
+        //         canonical,
+        //         formattedSection,
+        //     );
+        // }
+        0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use crate::{
+        euclid::{Point2D, Rect, Size2D},
+        legacy::{
+            bidi::Char16,
+            font_stack::FontStackHasher,
+            geometry_tile_data::{GeometryCoordinates, SymbolGeometryTileLayer},
+            glyph::{Glyph, GlyphDependencies, GlyphMap, GlyphMetrics, Glyphs},
+            glyph_atlas::{GlyphPosition, GlyphPositionMap, GlyphPositions},
+            image::ImageMap,
+            image_atlas::ImagePositions,
+            layout::{
+                layout::{BucketParameters, LayerTypeInfo, LayoutParameters},
+                symbol_feature::{SymbolGeometryTileFeature, VectorGeometryTileFeature},
+                symbol_layout::{FeatureIndex, LayerProperties, SymbolLayer, SymbolLayout},
+            },
+            style_types::SymbolLayoutProperties_Unevaluated,
+            tagged_string::SectionOptions,
+            CanonicalTileID, MapMode, OverscaledTileID,
+        },
+    };
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: test
+    fn test() {
+        let font_stack = vec![
+            "Open Sans Regular".to_string(),
+            "Arial Unicode MS Regular".to_string(),
+        ];
+
+        let section_options = SectionOptions::new(1.0, font_stack.clone(), None);
+
+        let mut glyph_dependencies = GlyphDependencies::new();
+
+        let tile_id = OverscaledTileID {
+            canonical: CanonicalTileID { x: 0, y: 0, z: 0 },
+            overscaled_z: 0,
+        };
+        let mut parameters = BucketParameters {
+            tile_id: tile_id,
+            mode: MapMode::Continuous,
+            pixel_ratio: 1.0,
+            layer_type: LayerTypeInfo,
+        };
+        let layer_data = SymbolGeometryTileLayer {
+            name: "layer".to_string(),
+            features: vec![SymbolGeometryTileFeature::new(Box::new(
+                VectorGeometryTileFeature {
+                    geometry: vec![GeometryCoordinates(vec![Point2D::new(1024, 1024)])],
+                },
+            ))],
+        };
+        let layer_properties = vec![LayerProperties {
+            id: "layer".to_string(),
+            layer: SymbolLayer {
+                layout: SymbolLayoutProperties_Unevaluated,
+            },
+        }];
+
+        let image_positions = ImagePositions::new();
+
+        let mut glyph_position = GlyphPosition {
+            rect: Rect::new(Point2D::new(0, 0), Size2D::new(10, 10)),
+            metrics: GlyphMetrics {
+                width: 18,
+                height: 18,
+                left: 2,
+                top: -8,
+                advance: 21,
+            },
+        };
+        let glyph_positions: GlyphPositions = GlyphPositions::from([(
+            FontStackHasher::new(&font_stack),
+            GlyphPositionMap::from([('中' as Char16, glyph_position)]),
+        )]);
+
+        let mut glyph = Glyph::default();
+        glyph.id = '中' as Char16;
+        glyph.metrics = glyph_position.metrics;
+
+        let glyphs: GlyphMap = GlyphMap::from([(
+            FontStackHasher::new(&font_stack),
+            Glyphs::from([('中' as Char16, Some(glyph))]),
+        )]);
+
+        let mut layout = SymbolLayout::new(
+            &parameters,
+            &layer_properties,
+            Box::new(layer_data),
+            &mut LayoutParameters {
+                bucket_parameters: &mut parameters.clone(),
+                glyph_dependencies: &mut glyph_dependencies,
+                image_dependencies: &mut Default::default(),
+                available_images: &mut Default::default(),
+            },
+        )
+        .unwrap();
+
+        assert_eq!(glyph_dependencies.len(), 1);
+
+        let empty_image_map = ImageMap::new();
+        layout.prepare_symbols(
+            &glyphs,
+            &glyph_positions,
+            &empty_image_map,
+            &image_positions,
+        );
+
+        let mut output = HashMap::new();
+        layout.create_bucket(
+            image_positions,
+            Box::new(FeatureIndex),
+            &mut output,
+            false,
+            false,
+            &tile_id.canonical,
+        );
+
+        println!(
+            "{:#?}",
+            output.get("layer").unwrap().bucket.text.shared_vertices
+        )
+    }
+}
diff --git a/maplibre/src/legacy/layout/symbol_projection.rs b/maplibre/src/legacy/layout/symbol_projection.rs
new file mode 100644
index 000000000..1b778b4ce
--- /dev/null
+++ b/maplibre/src/legacy/layout/symbol_projection.rs
@@ -0,0 +1,232 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/layout/symbol_projection.cpp
+
+use std::f64::consts::PI;
+
+use cgmath::{Matrix4, Vector4};
+
+use crate::{
+    euclid::Point2D,
+    legacy::{
+        buckets::symbol_bucket::PlacedSymbol,
+        geometry_tile_data::GeometryCoordinates,
+        util::math::{convert_point_f64, perp},
+        TileSpace,
+    },
+};
+
+/// maplibre/maplibre-native#4add9ea original name: PointAndCameraDistance
+type PointAndCameraDistance = (Point2D<f64, TileSpace>, f64); // TODO is the Unit correct?
+
+/// maplibre/maplibre-native#4add9ea original name: TileDistance
+pub struct TileDistance {
+    pub prev_tile_distance: f64,
+    pub last_segment_viewport_distance: f64,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: project
+pub fn project(point: Point2D<f64, TileSpace>, matrix: &Matrix4<f64>) -> PointAndCameraDistance {
+    let pos = Vector4::new(point.x, point.y, 0., 1.);
+    let pos = matrix * pos; // TODO verify this multiplications
+    (Point2D::new(pos[0] / pos[3], pos[1] / pos[3]), pos[3])
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PlacedGlyph
+pub struct PlacedGlyph {
+    pub point: Point2D<f64, TileSpace>,
+    pub angle: f64,
+    pub tile_distance: Option<TileDistance>,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: placeFirstAndLastGlyph
+pub fn place_first_and_last_glyph(
+    font_scale: f64,
+    line_offset_x: f64,
+    line_offset_y: f64,
+    flip: bool,
+    anchor_point: Point2D<f64, TileSpace>,
+    tile_anchor_point: Point2D<f64, TileSpace>,
+    symbol: &PlacedSymbol,
+    label_plane_matrix: &Matrix4<f64>,
+    return_tile_distance: bool,
+) -> Option<(PlacedGlyph, PlacedGlyph)> {
+    if symbol.glyph_offsets.is_empty() {
+        assert!(false);
+        return None;
+    }
+
+    let first_glyph_offset = *symbol.glyph_offsets.first().unwrap();
+    let last_glyph_offset = *symbol.glyph_offsets.last().unwrap();
+
+    if let (Some(first_placed_glyph), Some(last_placed_glyph)) = (
+        place_glyph_along_line(
+            font_scale * first_glyph_offset,
+            line_offset_x,
+            line_offset_y,
+            flip,
+            &anchor_point,
+            &tile_anchor_point,
+            symbol.segment as i16,
+            &symbol.line,
+            &symbol.tile_distances,
+            label_plane_matrix,
+            return_tile_distance,
+        ),
+        place_glyph_along_line(
+            font_scale * last_glyph_offset,
+            line_offset_x,
+            line_offset_y,
+            flip,
+            &anchor_point,
+            &tile_anchor_point,
+            symbol.segment as i16,
+            &symbol.line,
+            &symbol.tile_distances,
+            label_plane_matrix,
+            return_tile_distance,
+        ),
+    ) {
+        return Some((first_placed_glyph, last_placed_glyph));
+    }
+
+    None
+}
+
+/// maplibre/maplibre-native#4add9ea original name: placeGlyphAlongLine
+fn place_glyph_along_line(
+    offset_x: f64,
+    line_offset_x: f64,
+    line_offset_y: f64,
+    flip: bool,
+    projected_anchor_point: &Point2D<f64, TileSpace>,
+    tile_anchor_point: &Point2D<f64, TileSpace>,
+    anchor_segment: i16,
+    line: &GeometryCoordinates,
+    tile_distances: &Vec<f64>,
+    label_plane_matrix: &Matrix4<f64>,
+    return_tile_distance: bool,
+) -> Option<PlacedGlyph> {
+    let combined_offset_x = if flip {
+        offset_x - line_offset_x
+    } else {
+        offset_x + line_offset_x
+    };
+
+    let mut dir: i16 = if combined_offset_x > 0. { 1 } else { -1 };
+
+    let mut angle = 0.0;
+    if flip {
+        // The label needs to be flipped to keep text upright.
+        // Iterate in the reverse direction.
+        dir *= -1;
+        angle = PI;
+    }
+
+    if dir < 0 {
+        angle += PI;
+    }
+
+    let mut current_index = if dir > 0 {
+        anchor_segment
+    } else {
+        anchor_segment + 1
+    };
+
+    let initial_index = current_index;
+    let mut current = *projected_anchor_point;
+    let mut prev = *projected_anchor_point;
+    let mut distance_to_prev = 0.0;
+    let mut current_segment_distance = 0.0;
+    let abs_offset_x = combined_offset_x.abs();
+
+    while distance_to_prev + current_segment_distance <= abs_offset_x {
+        current_index += dir;
+
+        // offset does not fit on the projected line
+        if current_index < 0 || current_index >= line.len() as i16 {
+            return None;
+        }
+
+        prev = current;
+        let projection = project(
+            convert_point_f64(&line[current_index as usize]),
+            label_plane_matrix,
+        );
+        if projection.1 > 0. {
+            current = projection.0;
+        } else {
+            // The vertex is behind the plane of the camera, so we can't project it
+            // Instead, we'll create a vertex along the line that's far enough to include the glyph
+            let previous_tile_point = if distance_to_prev == 0. {
+                *tile_anchor_point
+            } else {
+                convert_point_f64(&line[(current_index - dir) as usize])
+            };
+
+            let current_tile_point = convert_point_f64(&line[current_index as usize]);
+            current = project_truncated_line_segment(
+                &previous_tile_point,
+                &current_tile_point,
+                &prev,
+                abs_offset_x - distance_to_prev + 1.,
+                label_plane_matrix,
+            );
+        }
+
+        distance_to_prev += current_segment_distance;
+        current_segment_distance = prev.distance_to(current); // TODO verify distance calculation is correct
+    }
+
+    // The point is on the current segment. Interpolate to find it.
+    let segment_interpolation_t = (abs_offset_x - distance_to_prev) / current_segment_distance;
+    let prev_to_current = current - prev;
+    let mut p = prev + (prev_to_current * segment_interpolation_t);
+
+    // offset the point from the line to text-offset and icon-offset
+    p += perp(&prev_to_current) * (line_offset_y * dir as f64 / prev_to_current.length()); // TODO verify if mag impl is correct mag == length?
+
+    let segment_angle = angle + (current.y - prev.y).atan2(current.x - prev.x); // TODO is this atan2 right?
+
+    Some(PlacedGlyph {
+        point: p,
+        angle: segment_angle,
+        tile_distance: if return_tile_distance {
+            Some(TileDistance {
+                // TODO are these the right fields assigned?
+                prev_tile_distance: if (current_index - dir) == initial_index {
+                    0.
+                } else {
+                    tile_distances[(current_index - dir) as usize]
+                },
+                last_segment_viewport_distance: abs_offset_x - distance_to_prev,
+            })
+        } else {
+            None
+        },
+    })
+}
+
+/// maplibre/maplibre-native#4add9ea original name: projectTruncatedLineSegment
+fn project_truncated_line_segment(
+    &previous_tile_point: &Point2D<f64, TileSpace>,
+    current_tile_point: &Point2D<f64, TileSpace>,
+    previous_projected_point: &Point2D<f64, TileSpace>,
+    minimum_length: f64,
+    projection_matrix: &Matrix4<f64>,
+) -> Point2D<f64, TileSpace> {
+    // We are assuming "previousTilePoint" won't project to a point within one
+    // unit of the camera plane If it did, that would mean our label extended
+    // all the way out from within the viewport to a (very distant) point near
+    // the plane of the camera. We wouldn't be able to render the label anyway
+    // once it crossed the plane of the camera.
+    let vec = previous_tile_point - *current_tile_point;
+    let projected_unit_vertex = project(
+        previous_tile_point + vec.try_normalize().unwrap_or(vec),
+        projection_matrix,
+    )
+    .0;
+    let projected_unit_segment = *previous_projected_point - projected_unit_vertex;
+
+    *previous_projected_point
+        + (projected_unit_segment * (minimum_length / projected_unit_segment.length()))
+    // TODO verify if mag impl is correct mag == length?
+}
diff --git a/maplibre/src/legacy/mod.rs b/maplibre/src/legacy/mod.rs
new file mode 100644
index 000000000..385c84152
--- /dev/null
+++ b/maplibre/src/legacy/mod.rs
@@ -0,0 +1,63 @@
+#![allow(dead_code)]
+#![allow(unused)]
+#![allow(unused_variables)]
+
+pub mod bidi;
+pub mod buckets;
+pub mod collision_feature;
+pub mod collision_index;
+pub mod font_stack;
+pub mod geometry;
+pub mod geometry_tile_data;
+pub mod glyph;
+pub mod glyph_atlas;
+pub mod glyph_range;
+pub mod grid_index;
+pub mod image;
+pub mod image_atlas;
+pub mod layout;
+pub mod quads;
+pub mod shaping;
+pub mod style_types;
+pub mod tagged_string;
+pub mod util;
+
+// TODO where should this live?
+pub struct TileSpace; // The unit in which geometries or symbols are on a tile (0-EXTENT)
+pub struct ScreenSpace;
+
+// TODO where should this live?
+/// maplibre/maplibre-native#4add9ea original name: MapMode
+#[derive(Copy, Clone, PartialEq)]
+pub enum MapMode {
+    ///< continually updating map
+    Continuous,
+    ///< a once-off still image of an arbitrary viewport
+    Static,
+    ///< a once-off still image of a single tile
+    Tile,
+}
+
+// TODO this is just a dummy
+/// maplibre/maplibre-native#4add9ea original name: CanonicalTileID
+#[derive(Copy, Clone)]
+pub struct CanonicalTileID {
+    pub x: u32,
+    pub y: u32,
+    pub z: u8,
+}
+
+// TODO
+/// maplibre/maplibre-native#4add9ea original name: OverscaledTileID
+#[derive(Copy, Clone)]
+pub struct OverscaledTileID {
+    pub canonical: CanonicalTileID,
+    pub overscaled_z: u8,
+}
+
+impl OverscaledTileID {
+    /// maplibre/maplibre-native#4add9ea original name: overscaleFactor
+    pub fn overscale_factor(&self) -> u32 {
+        1 << (self.overscaled_z - self.canonical.z)
+    }
+}
diff --git a/maplibre/src/legacy/quads.rs b/maplibre/src/legacy/quads.rs
new file mode 100644
index 000000000..6bcc138e4
--- /dev/null
+++ b/maplibre/src/legacy/quads.rs
@@ -0,0 +1,902 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/text/quads.cpp
+
+use std::f64::consts::PI;
+
+use crate::{
+    euclid::{Point2D, Rect, Size2D, Vector2D},
+    legacy::{
+        glyph::{Shaping, WritingModeType},
+        image::{ImageMap, ImageStretches},
+        image_atlas::ImagePosition,
+        layout::symbol_instance::SymbolContent,
+        shaping::PositionedIcon,
+        style_types::{
+            AlignmentType, SymbolLayoutProperties_Evaluated, SymbolPlacementType, TextRotate,
+            TextRotationAlignment,
+        },
+        util::{
+            constants::ONE_EM,
+            math::{deg2radf, rotate},
+        },
+        TileSpace,
+    },
+};
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolQuad
+pub struct SymbolQuad {
+    pub tl: Point2D<f64, TileSpace>,
+    pub tr: Point2D<f64, TileSpace>,
+    pub bl: Point2D<f64, TileSpace>,
+    pub br: Point2D<f64, TileSpace>,
+    pub tex: Rect<u16, TileSpace>,
+    pub pixel_offset_tl: Point2D<f64, TileSpace>,
+    pub pixel_offset_br: Point2D<f64, TileSpace>,
+    pub glyph_offset: Point2D<f64, TileSpace>,
+    pub writing_mode: WritingModeType,
+    pub is_sdf: bool,
+    pub section_index: usize,
+    pub min_font_scale: Point2D<f64, TileSpace>,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolQuads
+pub type SymbolQuads = Vec<SymbolQuad>;
+
+const BORDER: u16 = ImagePosition::PADDING;
+
+/// maplibre/maplibre-native#4add9ea original name: computeStretchSum
+fn compute_stretch_sum(stretches: &ImageStretches) -> f64 {
+    let mut sum = 0.;
+    for stretch in stretches {
+        sum += stretch.1 - stretch.0;
+    }
+    sum
+}
+
+/// maplibre/maplibre-native#4add9ea original name: sumWithinRange
+fn sum_within_range(stretches: &ImageStretches, min: f64, max: f64) -> f64 {
+    let mut sum = 0.;
+    for stretch in stretches {
+        sum += min.max(max.min(stretch.1)) - min.max(max.min(stretch.0));
+    }
+    sum
+}
+
+/// maplibre/maplibre-native#4add9ea original name: getEmOffset
+fn get_em_offset(stretch_offset: f64, stretch_size: f64, icon_size: f64, icon_offset: f64) -> f64 {
+    icon_offset + icon_size * stretch_offset / stretch_size
+}
+
+/// maplibre/maplibre-native#4add9ea original name: getPxOffset
+fn get_px_offset(
+    fixed_offset: f64,
+    fixed_size: f64,
+    stretch_offset: f64,
+    stretch_size: f64,
+) -> f64 {
+    fixed_offset - fixed_size * stretch_offset / stretch_size
+}
+
+/// maplibre/maplibre-native#4add9ea original name: Cut
+struct Cut {
+    fixed: f64,
+    stretch: f64,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: Cuts
+type Cuts = Vec<Cut>;
+
+/// maplibre/maplibre-native#4add9ea original name: stretchZonesToCuts
+fn stretch_zones_to_cuts(
+    stretch_zones: &ImageStretches,
+    fixed_size: f64,
+    stretch_size: f64,
+) -> Cuts {
+    let mut cuts = vec![Cut {
+        fixed: -(BORDER as f64),
+        stretch: 0.0,
+    }];
+
+    for zone in stretch_zones {
+        let c1 = zone.0;
+        let c2 = zone.1;
+        let last_stretch = cuts.last().unwrap().stretch;
+        cuts.push(Cut {
+            fixed: c1 - last_stretch,
+            stretch: last_stretch,
+        });
+        cuts.push(Cut {
+            fixed: c1 - last_stretch,
+            stretch: last_stretch + (c2 - c1),
+        });
+    }
+    cuts.push(Cut {
+        fixed: fixed_size + BORDER as f64,
+        stretch: stretch_size,
+    });
+    cuts
+}
+
+/// maplibre/maplibre-native#4add9ea original name: matrixMultiply
+fn matrix_multiply<U>(m: &[f64; 4], p: Point2D<f64, U>) -> Point2D<f64, U> {
+    Point2D::<f64, U>::new(m[0] * p.x + m[1] * p.y, m[2] * p.x + m[3] * p.y)
+}
+
+/// maplibre/maplibre-native#4add9ea original name: getIconQuads
+pub fn get_icon_quads(
+    shaped_icon: &PositionedIcon,
+    icon_rotate: f64,
+    icon_type: SymbolContent,
+    has_icon_text_fit: bool,
+) -> SymbolQuads {
+    let mut quads = Vec::new();
+
+    let image = &shaped_icon.image;
+    let pixel_ratio = image.pixel_ratio;
+    let image_width: u16 = image.padded_rect.width() - 2 * BORDER;
+    let image_height: u16 = image.padded_rect.height() - 2 * BORDER;
+
+    let icon_width = shaped_icon.right - shaped_icon.left;
+    let icon_height = shaped_icon.bottom - shaped_icon.top;
+
+    let stretch_xfull: ImageStretches = vec![(0.0, image_width as f64)];
+    let stretch_yfull: ImageStretches = vec![(0.0, image_height as f64)];
+    let stretch_x: &ImageStretches = if !image.stretch_x.is_empty() {
+        &image.stretch_x
+    } else {
+        &stretch_xfull
+    };
+    let stretch_y: &ImageStretches = if !image.stretch_y.is_empty() {
+        &image.stretch_y
+    } else {
+        &stretch_yfull
+    };
+
+    let stretch_width = compute_stretch_sum(stretch_x);
+    let stretch_height = compute_stretch_sum(stretch_y);
+    let fixed_width = image_width as f64 - stretch_width;
+    let fixed_height = image_height as f64 - stretch_height;
+
+    let mut stretch_offset_x = 0.;
+    let mut stretch_content_width = stretch_width;
+    let mut stretch_offset_y = 0.;
+    let mut stretch_content_height = stretch_height;
+    let mut fixed_offset_x = 0.;
+    let mut fixed_content_width = fixed_width;
+    let mut fixed_offset_y = 0.;
+    let mut fixed_content_height = fixed_height;
+
+    if has_icon_text_fit {
+        if let Some(content) = &image.content {
+            stretch_offset_x = sum_within_range(stretch_x, 0., content.left);
+            stretch_offset_y = sum_within_range(stretch_y, 0., content.top);
+            stretch_content_width = sum_within_range(stretch_x, content.left, content.right);
+            stretch_content_height = sum_within_range(stretch_y, content.top, content.bottom);
+            fixed_offset_x = content.left - stretch_offset_x;
+            fixed_offset_y = content.top - stretch_offset_y;
+            fixed_content_width = content.right - content.left - stretch_content_width;
+            fixed_content_height = content.bottom - content.top - stretch_content_height;
+        }
+    }
+
+    let mut matrix: Option<[f64; 4]> = None;
+    if icon_rotate != 0.0 {
+        // TODO is this correct?
+        let angle = deg2radf(icon_rotate);
+        let angle_sin = angle.sin();
+        let angle_cos = angle.cos();
+        matrix = Some([angle_cos, -angle_sin, angle_sin, angle_cos]);
+    }
+
+    let mut make_box = |left: &Cut, top: &Cut, right: &Cut, bottom: &Cut| {
+        let left_em = get_em_offset(
+            left.stretch - stretch_offset_x,
+            stretch_content_width,
+            icon_width,
+            shaped_icon.left,
+        );
+        let left_px = get_px_offset(
+            left.fixed - fixed_offset_x,
+            fixed_content_width,
+            left.stretch,
+            stretch_width,
+        );
+
+        let top_em = get_em_offset(
+            top.stretch - stretch_offset_y,
+            stretch_content_height,
+            icon_height,
+            shaped_icon.top,
+        );
+        let top_px = get_px_offset(
+            top.fixed - fixed_offset_y,
+            fixed_content_height,
+            top.stretch,
+            stretch_height,
+        );
+
+        let right_em = get_em_offset(
+            right.stretch - stretch_offset_x,
+            stretch_content_width,
+            icon_width,
+            shaped_icon.left,
+        );
+        let right_px = get_px_offset(
+            right.fixed - fixed_offset_x,
+            fixed_content_width,
+            right.stretch,
+            stretch_width,
+        );
+
+        let bottom_em = get_em_offset(
+            bottom.stretch - stretch_offset_y,
+            stretch_content_height,
+            icon_height,
+            shaped_icon.top,
+        );
+        let bottom_px = get_px_offset(
+            bottom.fixed - fixed_offset_y,
+            fixed_content_height,
+            bottom.stretch,
+            stretch_height,
+        );
+
+        let mut tl = Point2D::<f64, TileSpace>::new(left_em, top_em);
+        let mut tr = Point2D::<f64, TileSpace>::new(right_em, top_em);
+        let mut br = Point2D::<f64, TileSpace>::new(right_em, bottom_em);
+        let mut bl = Point2D::<f64, TileSpace>::new(left_em, bottom_em);
+        let pixel_offset_tl =
+            Point2D::<f64, TileSpace>::new(left_px / pixel_ratio, top_px / pixel_ratio);
+        let pixel_offset_br =
+            Point2D::<f64, TileSpace>::new(right_px / pixel_ratio, bottom_px / pixel_ratio);
+
+        if let Some(matrix) = matrix {
+            tl = matrix_multiply(&matrix, tl);
+            tr = matrix_multiply(&matrix, tr);
+            bl = matrix_multiply(&matrix, bl);
+            br = matrix_multiply(&matrix, br);
+        }
+
+        let x1 = left.stretch + left.fixed;
+        let x2 = right.stretch + right.fixed;
+        let y1 = top.stretch + top.fixed;
+        let y2 = bottom.stretch + bottom.fixed;
+
+        // TODO: consider making texture coordinates f64 instead of uint16_t
+        let sub_rect: Rect<u16, TileSpace> = Rect::new(
+            Point2D::new(
+                (image.padded_rect.origin.x as f64 + BORDER as f64 + x1) as u16,
+                (image.padded_rect.origin.y as f64 + BORDER as f64 + y1) as u16,
+            ),
+            Size2D::new((x2 - x1) as u16, (y2 - y1) as u16),
+        );
+
+        let min_font_scale_x = fixed_content_width / pixel_ratio / icon_width;
+        let min_font_scale_y = fixed_content_height / pixel_ratio / icon_height;
+
+        // Icon quad is padded, so texture coordinates also need to be padded.
+        quads.push(SymbolQuad {
+            tl,
+            tr,
+            bl,
+            br,
+            tex: sub_rect,
+            pixel_offset_tl,
+            pixel_offset_br,
+            glyph_offset: Point2D::new(0.0, 0.0),
+            writing_mode: WritingModeType::None,
+            is_sdf: icon_type == SymbolContent::IconSDF,
+            section_index: 0,
+            min_font_scale: Point2D::new(min_font_scale_x, min_font_scale_y),
+        });
+    };
+
+    if !has_icon_text_fit || (image.stretch_x.is_empty() && image.stretch_y.is_empty()) {
+        make_box(
+            &Cut {
+                fixed: 0.,
+                stretch: -1.,
+            },
+            &Cut {
+                fixed: 0.,
+                stretch: -1.,
+            },
+            &Cut {
+                fixed: 0.,
+                stretch: (image_width + 1) as f64,
+            },
+            &Cut {
+                fixed: 0.,
+                stretch: (image_height + 1) as f64,
+            },
+        );
+    } else {
+        let x_cuts = stretch_zones_to_cuts(stretch_x, fixed_width, stretch_width);
+        let y_cuts = stretch_zones_to_cuts(stretch_y, fixed_height, stretch_height);
+
+        for xi in 0..x_cuts.len() - 1 {
+            let x1 = &x_cuts[xi];
+            let x2 = &x_cuts[xi + 1];
+            for yi in 0..y_cuts.len() - 1 {
+                let y1 = &y_cuts[yi];
+                let y2 = &y_cuts[yi + 1];
+                make_box(x1, y1, x2, y2);
+            }
+        }
+    }
+
+    quads
+}
+
+/// maplibre/maplibre-native#4add9ea original name: getGlyphQuads
+pub fn get_glyph_quads(
+    shaped_text: &Shaping,
+    text_offset: [f64; 2],
+    layout: &SymbolLayoutProperties_Evaluated,
+    placement: SymbolPlacementType,
+    image_map: &ImageMap,
+    allow_vertical_placement: bool,
+) -> SymbolQuads {
+    let text_rotate: f64 = deg2radf(layout.get_eval::<TextRotate>());
+    let along_line: bool = layout.get::<TextRotationAlignment>() == AlignmentType::Map
+        && placement != SymbolPlacementType::Point;
+
+    let mut quads = Vec::new();
+
+    for line in &shaped_text.positioned_lines {
+        for positioned_glyph in &line.positioned_glyphs {
+            if positioned_glyph.rect.is_empty() {
+                continue;
+            }
+
+            // The rects have an addditional buffer that is not included in their size;
+            let glyph_padding = 1.0;
+            let mut rect_buffer = 3.0 + glyph_padding;
+            let mut pixel_ratio = 1.0;
+            let mut line_offset = 0.0;
+            let rotate_vertical_glyph =
+                (along_line || allow_vertical_placement) && positioned_glyph.vertical;
+            let half_advance =
+                positioned_glyph.metrics.advance as f64 * positioned_glyph.scale / 2.0;
+            let rect = positioned_glyph.rect;
+            let mut is_sdf = true;
+
+            // Align images and scaled glyphs in the middle of a vertical line.
+            if allow_vertical_placement && shaped_text.verticalizable {
+                let scaled_glyph_offset = (positioned_glyph.scale - 1.) * ONE_EM;
+                let image_offset =
+                    (ONE_EM - positioned_glyph.metrics.width as f64 * positioned_glyph.scale) / 2.0;
+                line_offset = line.line_offset / 2.0
+                    - (if positioned_glyph.image_id.is_some() {
+                        -image_offset
+                    } else {
+                        scaled_glyph_offset
+                    });
+            }
+
+            if let Some(image_id) = &positioned_glyph.image_id {
+                let image = image_map.get(image_id);
+                if let Some(image) = image {
+                    pixel_ratio = image.pixel_ratio;
+                    rect_buffer = ImagePosition::PADDING as f64 / pixel_ratio;
+                    is_sdf = image.sdf;
+                }
+            }
+
+            let glyph_offset = if along_line {
+                Point2D::new(positioned_glyph.x + half_advance, positioned_glyph.y)
+            } else {
+                Point2D::new(0.0, 0.0)
+            };
+
+            let mut built_in_offset = if along_line {
+                Vector2D::new(0.0, 0.0)
+            } else {
+                Vector2D::new(
+                    positioned_glyph.x + half_advance + text_offset[0],
+                    positioned_glyph.y + text_offset[1] - line_offset,
+                )
+            };
+
+            let mut verticalized_label_offset = Vector2D::<f64, TileSpace>::new(0.0, 0.0);
+            if rotate_vertical_glyph {
+                // Vertical POI labels, that are rotated 90deg CW and whose
+                // glyphs must preserve upright orientation need to be rotated
+                // 90deg CCW. After quad is rotated, it is translated to the
+                // original built-in offset.
+                verticalized_label_offset = built_in_offset;
+                built_in_offset = Vector2D::new(0.0, 0.0);
+            }
+
+            let x1 = (positioned_glyph.metrics.left as f64 - rect_buffer) * positioned_glyph.scale
+                - half_advance
+                + built_in_offset.x;
+            let y1 = (-positioned_glyph.metrics.top as f64 - rect_buffer) * positioned_glyph.scale
+                + built_in_offset.y;
+            let x2 = x1 + rect.width() as f64 * positioned_glyph.scale / pixel_ratio;
+            let y2 = y1 + rect.height() as f64 * positioned_glyph.scale / pixel_ratio;
+
+            let mut tl: Point2D<f64, TileSpace> = Point2D::new(x1, y1);
+            let mut tr: Point2D<f64, TileSpace> = Point2D::new(x2, y1);
+            let mut bl: Point2D<f64, TileSpace> = Point2D::new(x1, y2);
+            let mut br: Point2D<f64, TileSpace> = Point2D::new(x2, y2);
+
+            if rotate_vertical_glyph {
+                // Vertical-supporting glyphs are laid out in 24x24 point boxes
+                // (1 square em) In horizontal orientation, the y values for
+                // glyphs are below the midline and we use a "yOffset" of -17 to
+                // pull them up to the middle. By rotating counter-clockwise
+                // around the point at the center of the left edge of a 24x24
+                // layout box centered below the midline, we align the center of
+                // the glyphs with the horizontal midline, so the yOffset is no
+                // longer necessary, but we also pull the glyph to the left
+                // along the x axis. The y coordinate includes baseline yOffset,
+                // therefore, needs to be accounted for when glyph is rotated
+                // and translated.
+
+                let center = Point2D::new(-half_advance, half_advance - Shaping::Y_OFFSET as f64);
+                let vertical_rotation = -PI / 2.;
+
+                // xHalfWidhtOffsetcorrection is a difference between full-width
+                // and half-width advance, should be 0 for full-width glyphs and
+                // will pull up half-width glyphs.
+                let x_half_widht_offsetcorrection = ONE_EM / 2. - half_advance;
+                let y_image_offset_correction = if positioned_glyph.image_id.is_some() {
+                    x_half_widht_offsetcorrection
+                } else {
+                    0.0
+                };
+
+                let x_offset_correction = Vector2D::<f64, TileSpace>::new(
+                    5.0 - Shaping::Y_OFFSET as f64 - x_half_widht_offsetcorrection,
+                    -y_image_offset_correction,
+                );
+
+                tl = center
+                    + rotate(&(tl - center), vertical_rotation)
+                    + x_offset_correction
+                    + verticalized_label_offset;
+                tr = center
+                    + rotate(&(tr - center), vertical_rotation)
+                    + x_offset_correction
+                    + verticalized_label_offset;
+                bl = center
+                    + rotate(&(bl - center), vertical_rotation)
+                    + x_offset_correction
+                    + verticalized_label_offset;
+                br = center
+                    + rotate(&(br - center), vertical_rotation)
+                    + x_offset_correction
+                    + verticalized_label_offset;
+            }
+
+            if text_rotate != 0.0 {
+                // TODO is this correct?
+                // Compute the transformation matrix.
+                let angle_sin = text_rotate.sin();
+                let angle_cos = text_rotate.cos();
+                let matrix = [angle_cos, -angle_sin, angle_sin, angle_cos];
+
+                tl = matrix_multiply(&matrix, tl);
+                tr = matrix_multiply(&matrix, tr);
+                bl = matrix_multiply(&matrix, bl);
+                br = matrix_multiply(&matrix, br);
+            }
+
+            let pixel_offset_tl = Point2D::default();
+            let pixel_offset_br = Point2D::default();
+            let min_font_scale = Point2D::default();
+
+            quads.push(SymbolQuad {
+                tl,
+                tr,
+                bl,
+                br,
+                tex: rect,
+                pixel_offset_tl,
+                pixel_offset_br,
+                glyph_offset,
+                writing_mode: shaped_text.writing_mode,
+                is_sdf,
+                section_index: positioned_glyph.section_index,
+                min_font_scale,
+            });
+        }
+    }
+
+    quads
+}
+#[cfg(test)]
+mod tests {
+    use cgmath::ulps_eq;
+
+    use crate::{
+        euclid::{Point2D, Rect, Size2D},
+        legacy::{
+            geometry::anchor::Anchor,
+            geometry_tile_data::GeometryCoordinates,
+            glyph::{PositionedGlyph, PositionedLine, Shaping, WritingModeType},
+            image_atlas::ImagePosition,
+            layout::symbol_instance::SymbolContent,
+            quads::get_icon_quads,
+            shaping::PositionedIcon,
+            style_types::{IconTextFitType, SymbolAnchorType, SymbolLayoutProperties_Evaluated},
+        },
+    };
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: getIconQuads_normal
+    pub fn get_icon_quads_normal() {
+        let layout = SymbolLayoutProperties_Evaluated;
+        let anchor = Anchor {
+            point: Point2D::new(2.0, 3.0),
+            angle: 0.0,
+            segment: Some(0),
+        };
+        let image: ImagePosition = ImagePosition {
+            pixel_ratio: 1.0,
+            padded_rect: Rect::new(Point2D::origin(), Size2D::new(15, 11)),
+            version: 0,
+            stretch_x: vec![],
+            stretch_y: vec![],
+            content: None,
+        };
+
+        let shaped_icon =
+            PositionedIcon::shape_icon(image.clone(), &[-6.5, -4.5], SymbolAnchorType::Center);
+
+        let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+        assert_eq!(quads.len(), 1);
+        let quad = &quads[0];
+        ulps_eq!(quad.tl.x, -14.);
+        ulps_eq!(quad.tl.y, -10.);
+        ulps_eq!(quad.tr.x, 1.);
+        ulps_eq!(quad.tr.y, -10.);
+        ulps_eq!(quad.bl.x, -14.);
+        ulps_eq!(quad.bl.y, 1.);
+        ulps_eq!(quad.br.x, 1.);
+        ulps_eq!(quad.br.y, 1.);
+    }
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: getIconQuads_style
+    pub fn get_icon_quads_style() {
+        let anchor = Anchor {
+            point: Point2D::new(0.0, 0.0),
+            angle: 0.0,
+            segment: Some(0),
+        };
+
+        let image: ImagePosition = ImagePosition {
+            pixel_ratio: 1.0,
+            padded_rect: Rect::new(Point2D::origin(), Size2D::new(20, 20)),
+            version: 0,
+            stretch_x: vec![],
+            stretch_y: vec![],
+            content: None,
+        };
+
+        let line = GeometryCoordinates::default();
+        let mut shaped_text: Shaping = Shaping {
+            top: -10.,
+            bottom: 30.0,
+            left: -60.,
+            right: 20.0,
+
+            positioned_lines: vec![],
+            writing_mode: WritingModeType::None,
+            verticalizable: false,
+            icons_in_text: false,
+        };
+
+        // shapedText.positionedGlyphs.emplace_back(PositionedGlyph(32, 0.0, 0.0, false, 0, 1.0));
+
+        shaped_text.positioned_lines.push(PositionedLine::default());
+        shaped_text
+            .positioned_lines
+            .last_mut()
+            .unwrap()
+            .positioned_glyphs
+            .push(PositionedGlyph {
+                glyph: 32,
+                x: 0.0,
+                y: 0.0,
+                vertical: false,
+                font: 0,
+                scale: 0.0,
+                rect: Default::default(),
+                metrics: Default::default(),
+                image_id: None,
+                section_index: 0,
+            });
+
+        // none
+        {
+            let shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+
+            ulps_eq!(-18.5, shaped_icon.top);
+            ulps_eq!(-0.5, shaped_icon.right);
+            ulps_eq!(-0.5, shaped_icon.bottom);
+            ulps_eq!(-18.5, shaped_icon.left);
+
+            let layout = SymbolLayoutProperties_Evaluated;
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -19.5);
+            ulps_eq!(quad.tl.y, -19.5);
+            ulps_eq!(quad.tr.x, 0.5);
+            ulps_eq!(quad.tr.y, -19.5);
+            ulps_eq!(quad.bl.x, -19.5);
+            ulps_eq!(quad.bl.y, 0.5);
+            ulps_eq!(quad.br.x, 0.5);
+            ulps_eq!(quad.br.y, 0.5);
+        }
+
+        // width
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Width,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                24.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -64.4444427);
+            ulps_eq!(quad.tl.y, 0.);
+            ulps_eq!(quad.tr.x, 24.4444427);
+            ulps_eq!(quad.tr.y, 0.);
+            ulps_eq!(quad.bl.x, -64.4444427);
+            ulps_eq!(quad.bl.y, 20.);
+            ulps_eq!(quad.br.x, 24.4444427);
+            ulps_eq!(quad.br.y, 20.);
+        }
+
+        // width x textSize
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Width,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -32.2222214);
+            ulps_eq!(quad.tl.y, -5.);
+            ulps_eq!(quad.tr.x, 12.2222214);
+            ulps_eq!(quad.tr.y, -5.);
+            ulps_eq!(quad.bl.x, -32.2222214);
+            ulps_eq!(quad.bl.y, 15.);
+            ulps_eq!(quad.br.x, 12.2222214);
+            ulps_eq!(quad.br.y, 15.);
+        }
+
+        // width x textSize + padding
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Width,
+                &[5., 10., 5., 10.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -43.3333321);
+            ulps_eq!(quad.tl.y, -5.);
+            ulps_eq!(quad.tr.x, 23.3333321);
+            ulps_eq!(quad.tr.y, -5.);
+            ulps_eq!(quad.bl.x, -43.3333321);
+            ulps_eq!(quad.bl.y, 15.);
+            ulps_eq!(quad.br.x, 23.3333321);
+            ulps_eq!(quad.br.y, 15.);
+        }
+
+        // height
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Height,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                24.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -30.);
+            ulps_eq!(quad.tl.y, -12.2222214);
+            ulps_eq!(quad.tr.x, -10.);
+            ulps_eq!(quad.tr.y, -12.2222214);
+            ulps_eq!(quad.bl.x, -30.);
+            ulps_eq!(quad.bl.y, 32.2222214);
+            ulps_eq!(quad.br.x, -10.);
+            ulps_eq!(quad.br.y, 32.2222214);
+        }
+
+        // height x textSize
+        {
+            let layout = SymbolLayoutProperties_Evaluated;
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Height,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -20.);
+            ulps_eq!(quad.tl.y, -6.11111069);
+            ulps_eq!(quad.tr.x, 0.);
+            ulps_eq!(quad.tr.y, -6.11111069);
+            ulps_eq!(quad.bl.x, -20.);
+            ulps_eq!(quad.bl.y, 16.1111107);
+            ulps_eq!(quad.br.x, 0.);
+            ulps_eq!(quad.br.y, 16.1111107);
+        }
+
+        // height x textSize + padding
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Height,
+                &[5., 10., 5., 20.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -20.);
+            ulps_eq!(quad.tl.y, -11.666666);
+            ulps_eq!(quad.tr.x, 0.);
+            ulps_eq!(quad.tr.y, -11.666666);
+            ulps_eq!(quad.bl.x, -20.);
+            ulps_eq!(quad.bl.y, 21.666666);
+            ulps_eq!(quad.br.x, 0.);
+            ulps_eq!(quad.br.y, 21.666666);
+        }
+
+        // both
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Both,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                24.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -64.4444427);
+            ulps_eq!(quad.tl.y, -12.2222214);
+            ulps_eq!(quad.tr.x, 24.4444427);
+            ulps_eq!(quad.tr.y, -12.2222214);
+            ulps_eq!(quad.bl.x, -64.4444427);
+            ulps_eq!(quad.bl.y, 32.2222214);
+            ulps_eq!(quad.br.x, 24.4444427);
+            ulps_eq!(quad.br.y, 32.2222214);
+        }
+
+        // both x textSize
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Both,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -32.2222214);
+            ulps_eq!(quad.tl.y, -6.11111069);
+            ulps_eq!(quad.tr.x, 12.2222214);
+            ulps_eq!(quad.tr.y, -6.11111069);
+            ulps_eq!(quad.bl.x, -32.2222214);
+            ulps_eq!(quad.bl.y, 16.1111107);
+            ulps_eq!(quad.br.x, 12.2222214);
+            ulps_eq!(quad.br.y, 16.1111107);
+        }
+
+        // both x textSize + padding
+        {
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Both,
+                &[5., 10., 5., 10.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -43.3333321);
+            ulps_eq!(quad.tl.y, -11.666666);
+            ulps_eq!(quad.tr.x, 23.3333321);
+            ulps_eq!(quad.tr.y, -11.666666);
+            ulps_eq!(quad.bl.x, -43.3333321);
+            ulps_eq!(quad.bl.y, 21.666666);
+            ulps_eq!(quad.br.x, 23.3333321);
+            ulps_eq!(quad.br.y, 21.666666);
+        }
+
+        // both x textSize + padding t/r/b/l
+        {
+            let layout = SymbolLayoutProperties_Evaluated;
+            // FIXME add layout.get::<TextSize>() = 12.0; this test also works without this, which makes sense because text size does not affect glyph quads
+            let mut shaped_icon =
+                PositionedIcon::shape_icon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shaped_icon.fit_icon_to_text(
+                &shaped_text,
+                IconTextFitType::Both,
+                &[0., 5., 10., 15.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = get_icon_quads(&shaped_icon, 0., SymbolContent::IconRGBA, false);
+
+            assert_eq!(quads.len(), 1);
+            let quad = &quads[0];
+
+            ulps_eq!(quad.tl.x, -48.3333321);
+            ulps_eq!(quad.tl.y, -6.66666603);
+            ulps_eq!(quad.tr.x, 18.3333321);
+            ulps_eq!(quad.tr.y, -6.66666603);
+            ulps_eq!(quad.bl.x, -48.3333321);
+            ulps_eq!(quad.bl.y, 26.666666);
+            ulps_eq!(quad.br.x, 18.3333321);
+            ulps_eq!(quad.br.y, 26.666666);
+        }
+    }
+}
diff --git a/maplibre/src/legacy/shaping.rs b/maplibre/src/legacy/shaping.rs
new file mode 100644
index 000000000..82fb2a1f9
--- /dev/null
+++ b/maplibre/src/legacy/shaping.rs
@@ -0,0 +1,923 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/text/shaping.cpp
+
+use std::collections::BTreeSet;
+
+use cgmath::num_traits::Pow;
+
+use crate::{
+    euclid::Rect,
+    legacy::{
+        bidi::{BiDi, Char16},
+        glyph::{
+            Glyph, GlyphMap, GlyphMetrics, PositionedGlyph, PositionedLine, Shaping,
+            WritingModeType,
+        },
+        glyph_atlas::GlyphPositions,
+        image_atlas::{ImagePosition, ImagePositions},
+        style_types::{IconTextFitType, SymbolAnchorType, TextJustifyType},
+        tagged_string::{SectionOptions, TaggedString},
+        util::{constants::ONE_EM, i18n},
+        TileSpace,
+    },
+};
+
+/// maplibre/maplibre-native#4add9ea original name: Padding
+#[derive(Clone, Copy, Default, PartialEq)]
+pub struct Padding {
+    pub left: f64,
+    pub top: f64,
+    pub right: f64,
+    pub bottom: f64,
+}
+
+impl From<Padding> for bool {
+    /// maplibre/maplibre-native#4add9ea original name: into
+    fn from(val: Padding) -> Self {
+        val.left != 0. || val.top != 0. || val.right != 0. || val.bottom != 0.
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: AnchorAlignment
+struct AnchorAlignment {
+    horizontal_align: f64,
+    vertical_align: f64,
+}
+impl AnchorAlignment {
+    /// maplibre/maplibre-native#4add9ea original name: getAnchorAlignment
+    fn get_anchor_alignment(anchor: SymbolAnchorType) -> AnchorAlignment {
+        let mut result = AnchorAlignment {
+            horizontal_align: 0.5,
+            vertical_align: 0.5,
+        };
+
+        match anchor {
+            SymbolAnchorType::Right
+            | SymbolAnchorType::TopRight
+            | SymbolAnchorType::BottomRight => {
+                result.horizontal_align = 1.0;
+            }
+
+            SymbolAnchorType::Left | SymbolAnchorType::TopLeft | SymbolAnchorType::BottomLeft => {
+                result.horizontal_align = 0.0;
+            }
+            _ => {}
+        }
+
+        match anchor {
+            SymbolAnchorType::Bottom
+            | SymbolAnchorType::BottomLeft
+            | SymbolAnchorType::BottomRight => {
+                result.vertical_align = 1.0;
+            }
+
+            SymbolAnchorType::Top | SymbolAnchorType::TopLeft | SymbolAnchorType::TopRight => {
+                result.vertical_align = 0.0;
+            }
+
+            _ => {}
+        }
+
+        result
+    }
+}
+
+// Choose the justification that matches the direction of the TextAnchor
+/// maplibre/maplibre-native#4add9ea original name: getAnchorJustification
+pub fn get_anchor_justification(anchor: &SymbolAnchorType) -> TextJustifyType {
+    match anchor {
+        SymbolAnchorType::Right | SymbolAnchorType::TopRight | SymbolAnchorType::BottomRight => {
+            TextJustifyType::Right
+        }
+        SymbolAnchorType::Left | SymbolAnchorType::TopLeft | SymbolAnchorType::BottomLeft => {
+            TextJustifyType::Left
+        }
+        _ => TextJustifyType::Center,
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PositionedIcon
+#[derive(Clone)]
+pub struct PositionedIcon {
+    pub image: ImagePosition,
+    pub top: f64,
+    pub bottom: f64,
+    pub left: f64,
+    pub right: f64,
+    pub collision_padding: Padding,
+}
+
+impl PositionedIcon {
+    /// maplibre/maplibre-native#4add9ea original name: shapeIcon
+    pub fn shape_icon(
+        image: ImagePosition,
+        icon_offset: &[f64; 2],
+        icon_anchor: SymbolAnchorType,
+    ) -> PositionedIcon {
+        let anchor_align = AnchorAlignment::get_anchor_alignment(icon_anchor);
+        let dx = icon_offset[0];
+        let dy = icon_offset[1];
+        let left = dx - image.display_size()[0] * anchor_align.horizontal_align;
+        let right = left + image.display_size()[0];
+        let top = dy - image.display_size()[1] * anchor_align.vertical_align;
+        let bottom = top + image.display_size()[1];
+
+        let mut collision_padding: Padding = Padding::default();
+        if let Some(content) = &image.content {
+            let content = content;
+            let pixel_ratio = image.pixel_ratio;
+            collision_padding.left = content.left / pixel_ratio;
+            collision_padding.top = content.top / pixel_ratio;
+            collision_padding.right = image.display_size()[0] - content.right / pixel_ratio;
+            collision_padding.bottom = image.display_size()[1] - content.bottom / pixel_ratio;
+        }
+
+        PositionedIcon {
+            image,
+            top,
+            bottom,
+            left,
+            right,
+            collision_padding: collision_padding,
+        }
+    }
+
+    // Updates shaped icon's bounds based on shaped text's bounds and provided
+    // layout properties.
+    /// maplibre/maplibre-native#4add9ea original name: fitIconToText
+    pub fn fit_icon_to_text(
+        &mut self,
+        shaped_text: &Shaping,
+        text_fit: IconTextFitType,
+        padding: &[f64; 4],
+        icon_offset: &[f64; 2],
+        font_scale: f64,
+    ) {
+        assert!(text_fit != IconTextFitType::None);
+        // TODO assert!(shapedText);
+
+        // We don't respect the icon-anchor, because icon-text-fit is set. Instead,
+        // the icon will be centered on the text, then stretched in the given
+        // dimensions.
+
+        let text_left = shaped_text.left * font_scale;
+        let text_right = shaped_text.right * font_scale;
+
+        if text_fit == IconTextFitType::Width || text_fit == IconTextFitType::Both {
+            // Stretched horizontally to the text width
+            self.left = icon_offset[0] + text_left - padding[3];
+            self.right = icon_offset[0] + text_right + padding[1];
+        } else {
+            // Centered on the text
+            self.left =
+                icon_offset[0] + (text_left + text_right - self.image.display_size()[0]) / 2.0;
+            self.right = self.left + self.image.display_size()[0];
+        }
+
+        let text_top = shaped_text.top * font_scale;
+        let text_bottom = shaped_text.bottom * font_scale;
+        if text_fit == IconTextFitType::Height || text_fit == IconTextFitType::Both {
+            // Stretched vertically to the text height
+            self.top = icon_offset[1] + text_top - padding[0];
+            self.bottom = icon_offset[1] + text_bottom + padding[2];
+        } else {
+            // Centered on the text
+            self.top =
+                icon_offset[1] + (text_top + text_bottom - self.image.display_size()[1]) / 2.0;
+            self.bottom = self.top + self.image.display_size()[1];
+        }
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: getShaping
+pub fn get_shaping(
+    formatted_string: &TaggedString,
+    max_width: f64,
+    line_height: f64,
+    text_anchor: SymbolAnchorType,
+
+    text_justify: TextJustifyType,
+    spacing: f64,
+    translate: &[f64; 2],
+    writing_mode: WritingModeType,
+    bidi: &BiDi,
+    glyph_map: &GlyphMap,
+    glyph_positions: &GlyphPositions,
+    image_positions: &ImagePositions,
+    layout_text_size: f64,
+    layout_text_size_at_bucket_zoom_level: f64,
+    allow_vertical_placement: bool,
+) -> Shaping {
+    assert!(layout_text_size != 0.);
+    let mut reordered_lines: Vec<TaggedString> = Vec::new();
+    if formatted_string.section_count() == 1 {
+        let untagged_lines = bidi.process_text(
+            formatted_string.raw_text(),
+            determine_line_breaks(
+                formatted_string,
+                spacing,
+                max_width,
+                glyph_map,
+                image_positions,
+                layout_text_size,
+            ),
+        );
+        for line in untagged_lines {
+            reordered_lines.push(TaggedString::new_from_raw(
+                line,
+                formatted_string.section_at(0).clone(),
+            ));
+        }
+    } else {
+        let processed_lines = bidi.process_styled_text(
+            formatted_string.get_styled_text(),
+            determine_line_breaks(
+                formatted_string,
+                spacing,
+                max_width,
+                glyph_map,
+                image_positions,
+                layout_text_size,
+            ),
+        );
+        for line in processed_lines {
+            reordered_lines.push(TaggedString::new(
+                line,
+                formatted_string.get_sections().clone(),
+            ));
+        }
+    }
+    let mut shaping = Shaping::new(translate[0], translate[1], writing_mode);
+    shape_lines(
+        &mut shaping,
+        &mut reordered_lines,
+        spacing,
+        line_height,
+        text_anchor,
+        text_justify,
+        writing_mode,
+        glyph_map,
+        glyph_positions,
+        image_positions,
+        layout_text_size_at_bucket_zoom_level,
+        allow_vertical_placement,
+    );
+
+    shaping
+}
+
+// Zero width space that is used to suggest break points for Japanese labels.
+const ZWSP: Char16 = '\u{200b}' as Char16;
+
+/// maplibre/maplibre-native#4add9ea original name: align
+fn align(
+    shaping: &mut Shaping,
+    justify: f64,
+    horizontal_align: f64,
+    vertical_align: f64,
+    max_line_length: f64,
+    max_line_height: f64,
+    line_height: f64,
+    block_height: f64,
+    line_count: usize,
+) {
+    let shift_x = (justify - horizontal_align) * max_line_length;
+    let shift_y = if max_line_height != line_height {
+        -block_height * vertical_align - Shaping::Y_OFFSET as f64
+    } else {
+        (-vertical_align * (line_count) as f64 + 0.5) * line_height
+    };
+
+    for line in &mut shaping.positioned_lines {
+        for positioned_glyph in &mut line.positioned_glyphs {
+            positioned_glyph.x += shift_x;
+            positioned_glyph.y += shift_y;
+        }
+    }
+}
+
+// justify left = 0, right = 1, center = .5
+/// maplibre/maplibre-native#4add9ea original name: justifyLine
+fn justify_line(positioned_glyphs: &mut Vec<PositionedGlyph>, justify: f64, line_offset: f64) {
+    if justify == 0.0 && line_offset == 0.0 {
+        return;
+    }
+
+    let last_glyph = positioned_glyphs.last().unwrap();
+    let last_advance: f64 = last_glyph.metrics.advance as f64 * last_glyph.scale;
+    let line_indent = last_glyph.x + last_advance * justify;
+    for positioned_glyph in positioned_glyphs {
+        positioned_glyph.x -= line_indent;
+        positioned_glyph.y += line_offset;
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: getGlyphAdvance
+fn get_glyph_advance(
+    code_point: Char16,
+    section: &SectionOptions,
+    glyph_map: &GlyphMap,
+    image_positions: &ImagePositions,
+    layout_text_size: f64,
+    spacing: f64,
+) -> f64 {
+    if let Some(image_id) = &section.image_id {
+        let image = image_positions.get(image_id);
+        if image.is_none() {
+            return 0.0;
+        }
+        let image = image.unwrap();
+        image.display_size()[0] * section.scale * ONE_EM / layout_text_size + spacing
+    } else {
+        let glyphs = glyph_map.get(&section.font_stack_hash);
+        if glyphs.is_none() {
+            return 0.0;
+        }
+        let glyphs = glyphs.unwrap();
+        let it = glyphs.get(&code_point);
+
+        if it.is_none() {
+            return 0.0;
+        }
+
+        if it.expect("cant be none").is_none() {
+            return 0.0;
+        }
+
+        return (it
+            .expect("cant be none")
+            .as_ref()
+            .expect("cant be none")
+            .metrics
+            .advance as f64
+            * section.scale)
+            + spacing;
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: determine_average_line_width
+fn determine_average_line_width(
+    logical_input: &TaggedString,
+    spacing: f64,
+    max_width: f64,
+    glyph_map: &GlyphMap,
+    image_positions: &ImagePositions,
+    layout_text_size: f64,
+) -> f64 {
+    let mut total_width: f64 = 0.;
+
+    for i in 0..logical_input.length() {
+        let section = logical_input.get_section(i);
+        let code_point: Char16 = logical_input.get_char_code_at(i);
+        total_width += get_glyph_advance(
+            code_point,
+            section,
+            glyph_map,
+            image_positions,
+            layout_text_size,
+            spacing,
+        );
+    }
+
+    let target_line_count = (1.0f64).max((total_width / max_width).ceil()) as i32;
+    total_width / target_line_count as f64
+}
+
+/// maplibre/maplibre-native#4add9ea original name: calculateBadness
+fn calculate_badness(line_width: f64, target_width: f64, penalty: f64, is_last_break: bool) -> f64 {
+    let raggedness = (line_width - target_width).pow(2);
+    if is_last_break {
+        // Favor finals lines shorter than average over longer than average
+        if line_width < target_width {
+            return raggedness / 2.;
+        } else {
+            return raggedness * 2.;
+        }
+    }
+    if penalty < 0. {
+        return raggedness - penalty * penalty;
+    }
+    raggedness + penalty * penalty
+}
+
+/// maplibre/maplibre-native#4add9ea original name: calculatePenalty
+fn calculate_penalty(
+    code_point: Char16,
+    next_code_point: Char16,
+    penalizable_ideographic_break: bool,
+) -> f64 {
+    let mut penalty = 0.;
+    // Force break on newline
+    if code_point == 0x0au16 {
+        penalty -= 10000.;
+    }
+
+    // Penalize open parenthesis at end of line
+    if code_point == 0x28u16 || code_point == 0xff08u16 {
+        penalty += 50.;
+    }
+
+    // Penalize close parenthesis at beginning of line
+    if next_code_point == 0x29u16 || next_code_point == 0xff09u16 {
+        penalty += 50.;
+    }
+
+    // Penalize breaks between characters that allow ideographic breaking because
+    // they are less preferable than breaks at spaces (or zero width spaces)
+    if penalizable_ideographic_break {
+        penalty += 150.;
+    }
+
+    penalty
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PotentialBreak
+#[derive(Clone)]
+struct PotentialBreak {
+    pub index: usize,
+    pub x: f64,
+    pub prior_break: Option<Box<PotentialBreak>>, // TODO avoid Box
+    pub badness: f64,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: evaluateBreak
+fn evaluate_break(
+    break_index: usize,
+    break_x: f64,
+    target_width: f64,
+    potential_breaks: &Vec<PotentialBreak>,
+    penalty: f64,
+    is_last_break: bool,
+) -> PotentialBreak {
+    // We could skip evaluating breaks where the line length (breakX - priorBreak.x) > maxWidth
+    //  ...but in fact we allow lines longer than maxWidth (if there's no break points)
+    //  ...and when targetWidth and maxWidth are close, strictly enforcing maxWidth can give
+    //     more lopsided results.
+
+    let mut best_prior_break: Option<Box<PotentialBreak>> = None;
+    let mut best_break_badness: f64 =
+        calculate_badness(break_x, target_width, penalty, is_last_break);
+    for potential_break in potential_breaks {
+        let line_width = break_x - potential_break.x;
+        let break_badness = calculate_badness(line_width, target_width, penalty, is_last_break)
+            + potential_break.badness;
+        if break_badness <= best_break_badness {
+            best_prior_break = Some(Box::new(potential_break.clone()));
+            best_break_badness = break_badness;
+        }
+    }
+
+    PotentialBreak {
+        index: break_index,
+        x: break_x,
+        prior_break: best_prior_break,
+        badness: best_break_badness,
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: leastBadBreaks
+fn least_bad_breaks(last_line_break: &PotentialBreak) -> BTreeSet<usize> {
+    let mut least_bad_breaks: BTreeSet<usize> = BTreeSet::from([last_line_break.index]);
+    let mut prior_break = &last_line_break.prior_break;
+
+    while let Some(prior_break_) = prior_break {
+        least_bad_breaks.insert(prior_break_.index);
+        prior_break = &prior_break_.prior_break;
+    }
+    least_bad_breaks
+}
+
+// We determine line breaks based on shaped text in logical order. Working in visual order would be
+//  more intuitive, but we can't do that because the visual order may be changed by line breaks!
+/// maplibre/maplibre-native#4add9ea original name: determine_line_breaks
+fn determine_line_breaks(
+    logical_input: &TaggedString,
+    spacing: f64,
+    max_width: f64,
+    glyph_map: &GlyphMap,
+    image_positions: &ImagePositions,
+    layout_text_size: f64,
+) -> BTreeSet<usize> {
+    if max_width == 0.0 {
+        return BTreeSet::default();
+    }
+
+    if logical_input.empty() {
+        return BTreeSet::default();
+    }
+
+    let target_width = determine_average_line_width(
+        logical_input,
+        spacing,
+        max_width,
+        glyph_map,
+        image_positions,
+        layout_text_size,
+    );
+
+    let mut potential_breaks: Vec<PotentialBreak> = Vec::new();
+    let mut current_x: f64 = 0.;
+    // Find first occurance of zero width space (ZWSP) character.
+    let has_server_suggested_breaks = logical_input
+        .raw_text()
+        .as_slice()
+        .iter()
+        .any(|c| *c == ZWSP);
+
+    for i in 0..logical_input.length() {
+        let section = logical_input.get_section(i);
+        let code_point: Char16 = logical_input.get_char_code_at(i);
+        if !i18n::is_whitespace(code_point) {
+            current_x += get_glyph_advance(
+                code_point,
+                section,
+                glyph_map,
+                image_positions,
+                layout_text_size,
+                spacing,
+            );
+        }
+
+        // Ideographic characters, spaces, and word-breaking punctuation that
+        // often appear without surrounding spaces.
+        if i < logical_input.length() - 1 {
+            let allows_ideographic_break = i18n::allows_ideographic_breaking(code_point);
+            if section.image_id.is_some()
+                || allows_ideographic_break
+                || i18n::allows_word_breaking(code_point)
+            {
+                let penalizable_ideographic_break =
+                    allows_ideographic_break && has_server_suggested_breaks;
+                let next_index: usize = i + 1;
+                let potential_break = evaluate_break(
+                    next_index,
+                    current_x,
+                    target_width,
+                    &potential_breaks,
+                    calculate_penalty(
+                        code_point,
+                        logical_input.get_char_code_at(next_index),
+                        penalizable_ideographic_break,
+                    ),
+                    false,
+                );
+                potential_breaks.push(potential_break);
+            }
+        }
+    }
+
+    least_bad_breaks(&evaluate_break(
+        logical_input.length(),
+        current_x,
+        target_width,
+        &potential_breaks,
+        0.,
+        true,
+    ))
+}
+
+/// maplibre/maplibre-native#4add9ea original name: shapeLines
+fn shape_lines(
+    shaping: &mut Shaping,
+    lines: &mut Vec<TaggedString>,
+    spacing: f64,
+    line_height: f64,
+    text_anchor: SymbolAnchorType,
+    text_justify: TextJustifyType,
+    writing_mode: WritingModeType,
+    glyph_map: &GlyphMap,
+    glyph_positions: &GlyphPositions,
+    image_positions: &ImagePositions,
+    layout_text_size: f64,
+    allow_vertical_placement: bool,
+) {
+    let mut x = 0.0;
+    let mut y = Shaping::Y_OFFSET as f64;
+
+    let mut max_line_length = 0.0;
+    let mut max_line_height = 0.0;
+
+    // TODO was this translated correctly?
+    let justify = if text_justify == TextJustifyType::Right {
+        1.0
+    } else if text_justify == TextJustifyType::Left {
+        0.0
+    } else {
+        0.5
+    };
+
+    let n_lines = lines.len();
+
+    for line in lines {
+        // Collapse whitespace so it doesn't throw off justification
+        line.trim();
+
+        let line_max_scale = line.get_max_scale();
+        let max_line_offset = (line_max_scale - 1.0) * ONE_EM;
+        let mut line_offset = 0.0;
+        shaping.positioned_lines.push(PositionedLine::default());
+        let positioned_line = shaping.positioned_lines.last_mut().unwrap();
+        let positioned_glyphs = &mut positioned_line.positioned_glyphs;
+
+        if line.empty() {
+            y += line_height; // Still need a line feed after empty line
+            continue;
+        }
+
+        for i in 0..line.length() {
+            let section_index = line.get_section_index(i) as usize;
+            let section = line.section_at(section_index);
+            let code_point: Char16 = line.get_char_code_at(i);
+            let mut baseline_offset = 0.0;
+            let mut rect: Rect<u16, TileSpace> = Rect::default(); // TODO are these default values fine?
+            let mut metrics: GlyphMetrics = GlyphMetrics::default(); // TODO are these default values fine?
+            let mut advance = 0.0;
+            let mut vertical_advance = ONE_EM;
+            let mut section_scale = section.scale;
+            assert_ne!(section_scale, 0.0);
+
+            let vertical = !(writing_mode == WritingModeType::Horizontal ||
+                // Don't verticalize glyphs that have no upright orientation
+                // if vertical placement is disabled.
+                (!allow_vertical_placement && !i18n::has_upright_vertical_orientation(code_point)) ||
+                // If vertical placement is ebabled, don't verticalize glyphs
+                // that are from complex text layout script, or whitespaces.
+                (allow_vertical_placement &&
+                 (i18n::is_whitespace(code_point) || i18n::is_char_in_complex_shaping_script(code_point))));
+
+            if let Some(image_id) = &section.image_id {
+                let image = image_positions.get(image_id);
+                if image.is_none() {
+                    continue;
+                }
+                let image = image.expect("is some");
+
+                shaping.icons_in_text |= true;
+                let display_size = image.display_size();
+                metrics.width = (display_size[0]) as u32;
+                metrics.height = (display_size[1]) as u32;
+                metrics.left = ImagePosition::PADDING as i32;
+                metrics.top = -(Glyph::BORDER_SIZE as i32);
+                metrics.advance = if vertical {
+                    metrics.height
+                } else {
+                    metrics.width
+                };
+                rect = image.padded_rect;
+
+                // If needed, allow to set scale factor for an image using
+                // alias "image-scale" that could be alias for "font-scale"
+                // when FormattedSection is an image section.
+                section_scale = section_scale * ONE_EM / layout_text_size;
+
+                // Difference between one EM and an image size.
+                // Aligns bottom of an image to a baseline level.
+                let image_offset = ONE_EM - display_size[1] * section_scale;
+                baseline_offset = max_line_offset + image_offset;
+
+                vertical_advance = metrics.advance as f64;
+                advance = vertical_advance;
+
+                // Difference between height of an image and one EM at max line scale.
+                // Pushes current line down if an image size is over 1 EM at max line scale.
+                let offset = (if vertical {
+                    display_size[0]
+                } else {
+                    display_size[1]
+                }) * section_scale
+                    - ONE_EM * line_max_scale;
+                if offset > 0.0 && offset > line_offset {
+                    line_offset = offset;
+                }
+            } else {
+                let glyph_position_map = glyph_positions.get(&section.font_stack_hash); // TODO was .find
+                if glyph_position_map.is_none() {
+                    continue;
+                }
+
+                let glyph_position_map = glyph_position_map.expect("cant be none");
+
+                let glyph_position = glyph_position_map.get(&code_point);
+                if let Some(glyph_position) = glyph_position {
+                    rect = glyph_position.rect;
+                    metrics = glyph_position.metrics;
+                } else {
+                    let glyphs = glyph_map.get(&section.font_stack_hash);
+                    if glyphs.is_none() {
+                        continue;
+                    }
+                    let glyphs = glyphs.expect("cant be none");
+
+                    let glyph = glyphs.get(&code_point);
+
+                    if glyph.is_none() {
+                        continue;
+                    }
+
+                    if glyph.expect("cant be none").is_none() {
+                        continue;
+                    }
+
+                    metrics =
+                        (glyph.expect("cant be none").as_ref().expect("cant be none")).metrics;
+                }
+                advance = metrics.advance as f64;
+                // We don't know the baseline, but since we're laying out
+                // at 24 points, we can calculate how much it will move when
+                // we scale up or down.
+                baseline_offset = (line_max_scale - section_scale) * ONE_EM;
+            }
+
+            if !vertical {
+                positioned_glyphs.push(PositionedGlyph {
+                    glyph: code_point,
+                    x,
+                    y: y + baseline_offset,
+                    vertical,
+                    font: section.font_stack_hash,
+                    scale: section_scale,
+                    rect,
+                    metrics,
+                    image_id: section.image_id.clone(),
+                    section_index,
+                });
+                x += advance * section_scale + spacing;
+            } else {
+                positioned_glyphs.push(PositionedGlyph {
+                    glyph: code_point,
+                    x,
+                    y: y + baseline_offset,
+                    vertical,
+                    font: section.font_stack_hash,
+                    scale: section_scale,
+                    rect,
+                    metrics,
+                    image_id: section.image_id.clone(),
+                    section_index,
+                });
+                x += vertical_advance * section_scale + spacing;
+                shaping.verticalizable |= true;
+            }
+        }
+
+        // Only justify if we placed at least one glyph
+        if !positioned_glyphs.is_empty() {
+            let line_length = x - spacing; // Don't count trailing spacing
+            max_line_length = (line_length).max(max_line_length);
+            justify_line(positioned_glyphs, justify, line_offset);
+        }
+
+        let current_line_height = line_height * line_max_scale + line_offset;
+        x = 0.0;
+        y += current_line_height;
+        positioned_line.line_offset = (line_offset).max(max_line_offset);
+        max_line_height = (current_line_height).max(max_line_height);
+    }
+
+    let anchor_align = AnchorAlignment::get_anchor_alignment(text_anchor);
+    let height = y - Shaping::Y_OFFSET as f64;
+    align(
+        shaping,
+        justify,
+        anchor_align.horizontal_align,
+        anchor_align.vertical_align,
+        max_line_length,
+        max_line_height,
+        line_height,
+        height,
+        n_lines,
+    );
+
+    // Calculate the bounding box
+    shaping.top += -anchor_align.vertical_align * height;
+    shaping.bottom = shaping.top + height;
+    shaping.left += -anchor_align.horizontal_align * max_line_length;
+    shaping.right = shaping.left + max_line_length;
+}
+
+#[cfg(test)]
+mod test {
+    use crate::legacy::{
+        bidi::{BiDi, Char16},
+        font_stack::FontStackHasher,
+        glyph::{Glyph, GlyphMap, Glyphs, WritingModeType},
+        glyph_atlas::{GlyphPosition, GlyphPositionMap, GlyphPositions},
+        image_atlas::ImagePositions,
+        shaping::get_shaping,
+        style_types::{SymbolAnchorType, TextJustifyType},
+        tagged_string::{SectionOptions, TaggedString},
+        util::constants::ONE_EM,
+    };
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: Shaping_ZWSP
+    fn shaping_zwsp() {
+        let mut glyph_position = GlyphPosition::default();
+        glyph_position.metrics.width = 18;
+        glyph_position.metrics.height = 18;
+        glyph_position.metrics.left = 2;
+        glyph_position.metrics.top = -8;
+        glyph_position.metrics.advance = 21;
+
+        let mut glyph = Glyph::default();
+        glyph.id = '中' as Char16;
+        glyph.metrics = glyph_position.metrics;
+
+        let bidi = BiDi;
+        let font_stack = vec!["font-stack".to_string()];
+        let section_options = SectionOptions::new(1.0, font_stack.clone(), None);
+        let layout_text_size = 16.0;
+        let layout_text_size_at_bucket_zoom_level = 16.0;
+
+        let glyphs: GlyphMap = GlyphMap::from([(
+            FontStackHasher::new(&font_stack),
+            Glyphs::from([('中' as Char16, Some(glyph))]),
+        )]);
+
+        let glyph_positions: GlyphPositions = GlyphPositions::from([(
+            FontStackHasher::new(&font_stack),
+            GlyphPositionMap::from([('中' as Char16, glyph_position)]),
+        )]);
+        let image_positions: ImagePositions = ImagePositions::default();
+
+        let test_get_shaping = |string: &TaggedString, max_width_in_chars| {
+            return get_shaping(
+                string,
+                max_width_in_chars as f64 * ONE_EM,
+                ONE_EM, // lineHeight
+                SymbolAnchorType::Center,
+                TextJustifyType::Center,
+                0.,          // spacing
+                &[0.0, 0.0], // translate
+                WritingModeType::Horizontal,
+                &bidi,
+                &glyphs,
+                &glyph_positions,
+                &image_positions,
+                layout_text_size,
+                layout_text_size_at_bucket_zoom_level,
+                /*allowVerticalPlacement*/ false,
+            );
+        };
+
+        // 3 lines
+        // 中中中中中中
+        // 中中中中中中
+        // 中中
+        {
+            let string = TaggedString::new_from_raw(
+                "中中\u{200b}中中\u{200b}中中\u{200b}中中中中中中\u{200b}中中".into(),
+                section_options.clone(),
+            );
+            let shaping = test_get_shaping(&string, 5);
+            assert_eq!(shaping.positioned_lines.len(), 3);
+            assert_eq!(shaping.top, -36.);
+            assert_eq!(shaping.bottom, 36.);
+            assert_eq!(shaping.left, -63.);
+            assert_eq!(shaping.right, 63.);
+            assert_eq!(shaping.writing_mode, WritingModeType::Horizontal);
+        }
+
+        // 2 lines
+        // 中中
+        // 中
+        {
+            let string =
+                TaggedString::new_from_raw("中中\u{200b}中".into(), section_options.clone());
+            let shaping = test_get_shaping(&string, 1);
+            assert_eq!(shaping.positioned_lines.len(), 2);
+            assert_eq!(shaping.top, -24.);
+            assert_eq!(shaping.bottom, 24.);
+            assert_eq!(shaping.left, -21.);
+            assert_eq!(shaping.right, 21.);
+            assert_eq!(shaping.writing_mode, WritingModeType::Horizontal);
+        }
+
+        // 1 line
+        // 中中
+        {
+            let string = TaggedString::new_from_raw("中中\u{200b}".into(), section_options.clone());
+            let shaping = test_get_shaping(&string, 2);
+            assert_eq!(shaping.positioned_lines.len(), 1);
+            assert_eq!(shaping.top, -12.);
+            assert_eq!(shaping.bottom, 12.);
+            assert_eq!(shaping.left, -21.);
+            assert_eq!(shaping.right, 21.);
+            assert_eq!(shaping.writing_mode, WritingModeType::Horizontal);
+        }
+
+        // 5 'new' lines.
+        {
+            let string = TaggedString::new_from_raw(
+                "\u{200b}\u{200b}\u{200b}\u{200b}\u{200b}".into(),
+                section_options.clone(),
+            );
+            let shaping = test_get_shaping(&string, 1);
+            assert_eq!(shaping.positioned_lines.len(), 5);
+            assert_eq!(shaping.top, -60.);
+            assert_eq!(shaping.bottom, 60.);
+            assert_eq!(shaping.left, 0.);
+            assert_eq!(shaping.right, 0.);
+            assert_eq!(shaping.writing_mode, WritingModeType::Horizontal);
+        }
+    }
+}
diff --git a/maplibre/src/legacy/style_types.rs b/maplibre/src/legacy/style_types.rs
new file mode 100644
index 000000000..442ea094a
--- /dev/null
+++ b/maplibre/src/legacy/style_types.rs
@@ -0,0 +1,1212 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/include/mbgl/style/types.hpp
+//! and https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/style/layers/symbol_layer_properties.hpp
+
+use std::{any::TypeId, collections::BTreeSet, marker::PhantomData};
+
+use crate::legacy::{layout::symbol_feature::SymbolGeometryTileFeature, CanonicalTileID};
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolPlacementType
+#[derive(Clone, Copy, PartialEq)]
+pub enum SymbolPlacementType {
+    Point,
+    Line,
+    LineCenter,
+}
+/// maplibre/maplibre-native#4add9ea original name: SymbolAnchorType
+#[derive(Clone, Copy, PartialEq)]
+pub enum SymbolAnchorType {
+    Center,
+    Left,
+    Right,
+    Top,
+    Bottom,
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextJustifyType
+#[derive(Clone, Copy, PartialEq)]
+pub enum TextJustifyType {
+    Auto,
+    Center,
+    Left,
+    Right,
+}
+/// maplibre/maplibre-native#4add9ea original name: IconTextFitType
+#[derive(Clone, Copy, PartialEq)]
+pub enum IconTextFitType {
+    None,
+    Both,
+    Width,
+    Height,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextWritingModeType
+#[derive(PartialOrd, Ord, PartialEq, Eq, Copy, Clone, Debug)]
+pub enum TextWritingModeType {
+    Horizontal = 0,
+    Vertical = 1,
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextVariableAnchorType
+pub type TextVariableAnchorType = SymbolAnchorType;
+
+/// maplibre/maplibre-native#4add9ea original name: AlignmentType
+#[derive(Clone, Copy, PartialEq)]
+pub enum AlignmentType {
+    Map,
+    Viewport,
+    Auto,
+}
+/// maplibre/maplibre-native#4add9ea original name: TextTransformType
+#[derive(Clone, Copy, PartialEq)]
+pub enum TextTransformType {
+    None,
+    Uppercase,
+    Lowercase,
+}
+/// maplibre/maplibre-native#4add9ea original name: SymbolZOrderType
+#[derive(Clone, Copy, PartialEq)]
+pub enum SymbolZOrderType {
+    Auto,
+    ViewportY,
+    Source,
+}
+/// maplibre/maplibre-native#4add9ea original name: PropertyValue
+#[derive(Clone, PartialEq)]
+pub struct PropertyValue<T> {
+    value: expression::Value,
+    _phandom: PhantomData<T>,
+}
+
+impl<T> Default for PropertyValue<T> {
+    /// maplibre/maplibre-native#4add9ea original name: default
+    fn default() -> Self {
+        // TODO
+        PropertyValue {
+            value: expression::Value::f64(0.0),
+            _phandom: Default::default(),
+        }
+    }
+}
+
+impl<T> PropertyValue<T> {
+    /// maplibre/maplibre-native#4add9ea original name: isUndefined
+    pub fn is_undefined(&self) -> bool {
+        // todo!()
+        false
+    }
+    /// maplibre/maplibre-native#4add9ea original name: isDataDriven
+    pub fn is_data_driven(&self) -> bool {
+        // todo!()
+        false
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: isZoomant
+    pub fn is_zoomant(&self) -> bool {
+        //  todo!()
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: PossiblyEvaluatedPropertyValue
+#[derive(Clone, PartialEq)]
+pub struct PossiblyEvaluatedPropertyValue<T> {
+    value: expression::Value,
+    _phandom: PhantomData<T>,
+}
+
+impl<T> Default for PossiblyEvaluatedPropertyValue<T> {
+    /// maplibre/maplibre-native#4add9ea original name: default
+    fn default() -> Self {
+        // TODO
+        PossiblyEvaluatedPropertyValue {
+            value: expression::Value::f64(0.0),
+            _phandom: Default::default(),
+        }
+    }
+}
+
+impl<T> PossiblyEvaluatedPropertyValue<T> {
+    /// maplibre/maplibre-native#4add9ea original name: constantOr
+    pub fn constant_or(&self, constant: T) -> T {
+        todo!()
+    }
+}
+
+pub trait LayoutProperty {
+    /// maplibre/maplibre-native#4add9ea original name: TransitionableType
+    // type TransitionableType = std::nullptr_t;
+
+    type UnevaluatedType;
+    /// maplibre/maplibre-native#4add9ea original name: EvaluatorType
+    // type EvaluatorType = PropertyEvaluator<T>;
+
+    type PossiblyEvaluatedType;
+
+    type Type;
+    const IS_DATA_DRIVEN: bool = false;
+    const IS_OVERRIDABLE: bool = false;
+
+    fn name() -> &'static str;
+
+    fn default_value() -> Self::Type;
+}
+
+pub trait DataDrivenLayoutProperty {
+    /// maplibre/maplibre-native#4add9ea original name: TransitionableType
+    // type TransitionableType = std::nullptr_t;
+
+    type UnevaluatedType: Default;
+    /// maplibre/maplibre-native#4add9ea original name: EvaluatorType
+    //type EvaluatorType = DataDrivenPropertyEvaluator<T>;
+
+    type PossiblyEvaluatedTyp: Default;
+
+    type Type;
+    const IS_DATA_DRIVEN: bool = true;
+    const IS_OVERRIDABLE: bool = false;
+
+    fn name() -> &'static str;
+
+    fn default_value() -> Self::Type;
+}
+
+// text
+/// maplibre/maplibre-native#4add9ea original name: IconAllowOverlap
+pub struct IconAllowOverlap {}
+
+impl LayoutProperty for IconAllowOverlap {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "icon-allow-overlap"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconAnchor
+pub struct IconAnchor {}
+
+impl DataDrivenLayoutProperty for IconAnchor {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = SymbolAnchorType;
+
+    fn name() -> &'static str {
+        "icon-anchor"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        SymbolAnchorType::Center
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconIgnorePlacement
+pub struct IconIgnorePlacement {}
+
+impl LayoutProperty for IconIgnorePlacement {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "icon-ignore-placement"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconImage
+pub struct IconImage {}
+
+impl DataDrivenLayoutProperty for IconImage {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = expression::Image;
+
+    fn name() -> &'static str {
+        "icon-image"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        expression::Image::default()
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconKeepUpright
+pub struct IconKeepUpright {}
+
+impl LayoutProperty for IconKeepUpright {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "icon-keep-upright"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconOffset
+pub struct IconOffset {}
+
+impl DataDrivenLayoutProperty for IconOffset {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = [f64; 2];
+
+    fn name() -> &'static str {
+        "icon-offset"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        [0.0, 0.0]
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconOptional
+pub struct IconOptional {}
+
+impl LayoutProperty for IconOptional {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "icon-optional"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconPadding
+pub struct IconPadding {}
+
+impl LayoutProperty for IconPadding {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "icon-padding"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        2.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconPitchAlignment
+pub struct IconPitchAlignment {}
+
+impl LayoutProperty for IconPitchAlignment {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = AlignmentType;
+
+    fn name() -> &'static str {
+        "icon-pitch-alignment"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        AlignmentType::Auto
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconRotate
+pub struct IconRotate {}
+
+impl DataDrivenLayoutProperty for IconRotate {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "icon-rotate"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        0.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconRotationAlignment
+pub struct IconRotationAlignment {}
+
+impl LayoutProperty for IconRotationAlignment {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = AlignmentType;
+
+    fn name() -> &'static str {
+        "icon-rotation-alignment"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        AlignmentType::Auto
+    }
+}
+/// maplibre/maplibre-native#4add9ea original name: IconSize
+pub struct IconSize {}
+
+impl DataDrivenLayoutProperty for IconSize {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "icon-size"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        1.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: IconTextFit
+pub struct IconTextFit {}
+
+impl LayoutProperty for IconTextFit {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = IconTextFitType;
+
+    fn name() -> &'static str {
+        "icon-text-fit"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        IconTextFitType::None
+    }
+}
+/// maplibre/maplibre-native#4add9ea original name: IconTextFitPadding
+pub struct IconTextFitPadding {}
+impl LayoutProperty for IconTextFitPadding {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = [f64; 4];
+
+    fn name() -> &'static str {
+        "icon-text-fit-padding"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        [0.0, 0.0, 0.0, 0.0]
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolAvoidEdges
+pub struct SymbolAvoidEdges {}
+
+impl LayoutProperty for SymbolAvoidEdges {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "symbol-avoid-edges"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolPlacement
+pub struct SymbolPlacement {}
+
+impl LayoutProperty for SymbolPlacement {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = SymbolPlacementType;
+
+    fn name() -> &'static str {
+        "symbol-placement"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        SymbolPlacementType::Point
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolSortKey
+pub struct SymbolSortKey {}
+
+impl DataDrivenLayoutProperty for SymbolSortKey {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "symbol-sort-key"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        0.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolSpacing
+pub struct SymbolSpacing {}
+
+impl LayoutProperty for SymbolSpacing {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "symbol-spacing"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        250.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolZOrder
+pub struct SymbolZOrder {}
+
+impl LayoutProperty for SymbolZOrder {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = SymbolZOrderType;
+
+    fn name() -> &'static str {
+        "symbol-z-order"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        SymbolZOrderType::Auto
+    }
+}
+/// maplibre/maplibre-native#4add9ea original name: TextAllowOverlap
+pub struct TextAllowOverlap {}
+
+impl LayoutProperty for TextAllowOverlap {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "text-allow-overlap"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextAnchor
+pub struct TextAnchor {}
+
+impl DataDrivenLayoutProperty for TextAnchor {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = SymbolAnchorType;
+
+    fn name() -> &'static str {
+        "text-anchor"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        SymbolAnchorType::Center
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextField
+pub struct TextField {}
+impl DataDrivenLayoutProperty for TextField {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = expression::Formatted;
+
+    fn name() -> &'static str {
+        "text-field"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        expression::Formatted::default()
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextFont
+pub struct TextFont {}
+
+impl DataDrivenLayoutProperty for TextFont {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = Vec<String>;
+
+    fn name() -> &'static str {
+        "text-font"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        vec![
+            "Open Sans Regular".to_string(),
+            "Arial Unicode MS Regular".to_string(),
+        ]
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextIgnorePlacement
+pub struct TextIgnorePlacement {}
+
+impl LayoutProperty for TextIgnorePlacement {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "text-ignore-placement"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextJustify
+pub struct TextJustify {}
+
+impl DataDrivenLayoutProperty for TextJustify {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = TextJustifyType;
+
+    fn name() -> &'static str {
+        "text-justify"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        TextJustifyType::Center
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextKeepUpright
+pub struct TextKeepUpright {}
+
+impl TextKeepUpright {}
+impl LayoutProperty for TextKeepUpright {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "text-keep-upright"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        true
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextLetterSpacing
+pub struct TextLetterSpacing {}
+
+impl TextLetterSpacing {}
+impl DataDrivenLayoutProperty for TextLetterSpacing {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-letter-spacing"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        0.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextLineHeight
+pub struct TextLineHeight {}
+
+impl TextLineHeight {}
+impl LayoutProperty for TextLineHeight {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-line-height"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        1.2
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextMaxAngle
+pub struct TextMaxAngle {}
+
+impl LayoutProperty for TextMaxAngle {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-max-angle"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        45.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextMaxWidth
+pub struct TextMaxWidth {}
+
+impl DataDrivenLayoutProperty for TextMaxWidth {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-max-width"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        10.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextOffset
+pub struct TextOffset {}
+
+impl DataDrivenLayoutProperty for TextOffset {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = [f64; 2];
+
+    fn name() -> &'static str {
+        "text-offset"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        [0.0, 0.0]
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextOptional
+pub struct TextOptional {}
+
+impl LayoutProperty for TextOptional {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = bool;
+
+    fn name() -> &'static str {
+        "text-optional"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        false
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextPadding
+pub struct TextPadding {}
+
+impl LayoutProperty for TextPadding {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-padding"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        2.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextPitchAlignment
+pub struct TextPitchAlignment {}
+
+impl TextPitchAlignment {}
+impl LayoutProperty for TextPitchAlignment {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = AlignmentType;
+
+    fn name() -> &'static str {
+        "text-pitch-alignment"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        AlignmentType::Auto
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextRadialOffset
+pub struct TextRadialOffset {}
+
+impl DataDrivenLayoutProperty for TextRadialOffset {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-radial-offset"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        0.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextRotate
+pub struct TextRotate {}
+
+impl DataDrivenLayoutProperty for TextRotate {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-rotate"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        0.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextRotationAlignment
+pub struct TextRotationAlignment {}
+
+impl LayoutProperty for TextRotationAlignment {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = AlignmentType;
+
+    fn name() -> &'static str {
+        "text-rotation-alignment"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        AlignmentType::Auto
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextSize
+pub struct TextSize {}
+
+impl DataDrivenLayoutProperty for TextSize {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = f64;
+
+    fn name() -> &'static str {
+        "text-size"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        16.0
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextTransform
+pub struct TextTransform {}
+
+impl DataDrivenLayoutProperty for TextTransform {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+
+    type Type = TextTransformType;
+
+    fn name() -> &'static str {
+        "text-transform"
+    }
+
+    fn default_value() -> <Self as DataDrivenLayoutProperty>::Type {
+        TextTransformType::None
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextVariableAnchor
+pub struct TextVariableAnchor {}
+
+impl TextVariableAnchor {}
+impl LayoutProperty for TextVariableAnchor {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = Vec<TextVariableAnchorType>;
+
+    fn name() -> &'static str {
+        "text-variable-anchor"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        Vec::new()
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: TextWritingMode
+pub struct TextWritingMode {}
+
+impl LayoutProperty for TextWritingMode {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+
+    type PossiblyEvaluatedType = Self::Type;
+
+    type Type = Vec<TextWritingModeType>;
+
+    fn name() -> &'static str {
+        "text-writing-mode"
+    }
+
+    fn default_value() -> <Self as LayoutProperty>::Type {
+        Vec::new()
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolLayoutProperties_Unevaluated
+#[derive(Clone, Debug)]
+pub struct SymbolLayoutProperties_Unevaluated;
+/// maplibre/maplibre-native#4add9ea original name: SymbolLayoutProperties_PossiblyEvaluated
+#[derive(Clone, Debug)]
+pub struct SymbolLayoutProperties_PossiblyEvaluated;
+
+impl SymbolLayoutProperties_PossiblyEvaluated {
+    /// maplibre/maplibre-native#4add9ea original name: has
+    pub fn has<T: 'static>(&self) -> bool {
+        // todo!() check actual style if property is not empty
+        //     return layout.get<Property>().match([](const typename Property::Type& t) { return !t.is_empty(); },
+        //                                         [](let) { return true; });
+        TypeId::of::<T>() == TypeId::of::<TextField>()
+            || TypeId::of::<T>() == TypeId::of::<TextFont>()
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: SymbolLayoutProperties_Evaluated
+#[derive(Clone)]
+pub struct SymbolLayoutProperties_Evaluated;
+
+pub mod expression {
+    use std::{
+        collections::{BTreeSet, HashMap},
+        rc::Rc,
+    };
+
+    use csscolorparser::Color;
+
+    use crate::legacy::{
+        font_stack::FontStack, layout::symbol_feature::SymbolGeometryTileFeature, CanonicalTileID,
+    };
+
+    /// maplibre/maplibre-native#4add9ea original name: Value
+    #[derive(Clone, PartialEq)]
+    pub enum Value {
+        Color(Color),
+        f64(f64),
+        Object(HashMap<String, Value>),
+    }
+
+    // TODO
+    /// maplibre/maplibre-native#4add9ea original name: Image
+    #[derive(Default, Clone)]
+    pub struct Image {
+        pub image_id: String,
+        pub available: bool,
+    }
+    /// maplibre/maplibre-native#4add9ea original name: Formatted
+    pub struct Formatted {
+        pub sections: Vec<FormattedSection>,
+    }
+
+    impl Default for Formatted {
+        /// maplibre/maplibre-native#4add9ea original name: default
+        fn default() -> Self {
+            // TODO remove
+            Formatted {
+                sections: vec![FormattedSection {
+                    text: "Aller Anfang ist schwer".to_string(),
+                    image: None,
+                    font_scale: None,
+                    font_stack: None,
+                    text_color: None,
+                }],
+            }
+        }
+    }
+
+    impl Formatted {
+        /// maplibre/maplibre-native#4add9ea original name: toString
+        fn to_string() -> String {
+            todo!()
+        }
+        /// maplibre/maplibre-native#4add9ea original name: toObject
+        fn to_object() -> Value {
+            todo!()
+        }
+
+        /// maplibre/maplibre-native#4add9ea original name: empty
+        fn empty() -> bool {
+            todo!()
+        }
+    }
+
+    impl PartialEq for Formatted {
+        /// maplibre/maplibre-native#4add9ea original name: eq
+        fn eq(&self, other: &Self) -> bool {
+            todo!()
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: FormattedSection
+    #[derive(Default)]
+    pub struct FormattedSection {
+        pub text: String,
+        pub image: Option<Image>,
+        pub font_scale: Option<f64>,
+        pub font_stack: Option<FontStack>,
+        pub text_color: Option<Color>,
+    }
+
+    pub const K_FORMATTED_SECTION_FONT_SCALE: &str = "font-scale";
+    pub const K_FORMATTED_SECTION_TEXT_FONT: &str = "text-font";
+    pub const K_FORMATTED_SECTION_TEXT_COLOR: &str = "text-color";
+
+    // TODO
+    /// maplibre/maplibre-native#4add9ea original name: FeatureState
+    pub type FeatureState = Value;
+
+    /// maplibre/maplibre-native#4add9ea original name: EvaluationContext
+    pub struct EvaluationContext {
+        zoom: Option<f64>,
+        accumulated: Option<Value>,
+        feature: Rc<SymbolGeometryTileFeature>,
+        color_ramp_parameter: Option<f64>,
+        // Contains formatted section object, std::unordered_map<std::string, Value>.
+        formatted_section: Rc<Value>,
+        feature_state: Rc<FeatureState>,
+        available_images: Rc<BTreeSet<String>>,
+        canonical: Rc<CanonicalTileID>,
+    }
+}
+
+// TODO
+/// maplibre/maplibre-native#4add9ea original name: PropertyEvaluationParameters(pub
+pub struct PropertyEvaluationParameters(pub f64);
+
+impl SymbolLayoutProperties_Unevaluated {
+    /// maplibre/maplibre-native#4add9ea original name: get_dynamic
+    pub fn get_dynamic<T: DataDrivenLayoutProperty>(&self) -> T::UnevaluatedType {
+        T::UnevaluatedType::default()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: evaluate
+    pub fn evaluate(
+        &self,
+        p0: PropertyEvaluationParameters,
+    ) -> SymbolLayoutProperties_PossiblyEvaluated {
+        // TODO
+        SymbolLayoutProperties_PossiblyEvaluated
+    }
+}
+
+// TODO generated
+impl SymbolLayoutProperties_PossiblyEvaluated {
+    /// maplibre/maplibre-native#4add9ea original name: get
+    pub fn get<T: LayoutProperty>(&self) -> T::Type {
+        // todo!()
+        T::default_value()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: set
+    pub fn set<T: LayoutProperty>(&mut self, value: T::Type) {
+        // todo!()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: get_dynamic
+    pub fn get_dynamic<T: DataDrivenLayoutProperty>(&self) -> T::PossiblyEvaluatedTyp {
+        T::PossiblyEvaluatedTyp::default()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: evaluate
+    pub fn evaluate<T: DataDrivenLayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::default_value()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: evaluate_feature
+    pub fn evaluate_feature(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+    ) -> SymbolLayoutProperties_Evaluated {
+        //
+        SymbolLayoutProperties_Evaluated
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: evaluate4
+    pub fn evaluate4<T: DataDrivenLayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        available_images: &BTreeSet<String>,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+
+        //p1.get_value(&T::name());
+
+        T::default_value()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: evaluate_static
+    pub fn evaluate_static<T: LayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::default_value()
+    }
+}
+
+impl SymbolLayoutProperties_Evaluated {
+    /// maplibre/maplibre-native#4add9ea original name: get
+    pub fn get<T: LayoutProperty>(&self) -> T::Type {
+        //todo!()
+        T::default_value()
+    }
+    /// maplibre/maplibre-native#4add9ea original name: set
+    pub fn set<T: LayoutProperty>(&mut self, value: T::Type) {
+        // todo!()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: get_dynamic
+    pub fn get_dynamic<T: DataDrivenLayoutProperty>(&self) -> T::PossiblyEvaluatedTyp {
+        // todo!()
+        T::PossiblyEvaluatedTyp::default()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: get_eval
+    pub fn get_eval<T: DataDrivenLayoutProperty>(&self) -> T::Type {
+        //todo!()
+        T::default_value()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: evaluate
+    pub fn evaluate<T: DataDrivenLayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::default_value()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: evaluate_static
+    pub fn evaluate_static<T: LayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::default_value()
+    }
+}
diff --git a/maplibre/src/legacy/tagged_string.rs b/maplibre/src/legacy/tagged_string.rs
new file mode 100644
index 000000000..6ad516eac
--- /dev/null
+++ b/maplibre/src/legacy/tagged_string.rs
@@ -0,0 +1,342 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/text/tagged_string.cpp
+
+use csscolorparser::Color;
+use widestring::{U16Str, U16String};
+
+use crate::legacy::{
+    bidi::{Char16, StyledText},
+    font_stack::{FontStack, FontStackHash, FontStackHasher},
+    util::{
+        i18n,
+        i18n::{BACKSLACK_F, BACKSLACK_V},
+    },
+};
+
+/// maplibre/maplibre-native#4add9ea original name: SectionOptions
+#[derive(Clone, Default)]
+pub struct SectionOptions {
+    pub scale: f64,
+    pub font_stack_hash: FontStackHash,
+    pub font_stack: FontStack,
+    pub text_color: Option<Color>,
+    pub image_id: Option<String>,
+}
+impl SectionOptions {
+    /// maplibre/maplibre-native#4add9ea original name: from_image_id
+    pub fn from_image_id(image_id: String) -> Self {
+        Self {
+            scale: 1.0,
+            image_id: Some(image_id),
+            ..SectionOptions::default()
+        }
+    }
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(scale: f64, font_stack: FontStack, text_color: Option<Color>) -> Self {
+        Self {
+            scale,
+            font_stack_hash: FontStackHasher::new(&font_stack),
+            font_stack,
+            text_color,
+            image_id: None,
+        }
+    }
+}
+
+const PUABEGIN: Char16 = '\u{E000}' as Char16;
+const PUAEND: Char16 = '\u{F8FF}' as Char16;
+
+/**
+ * A TaggedString is the shaping-code counterpart of the Formatted type
+ * Whereas Formatted matches the logical structure of a 'format' expression,
+ * a TaggedString represents the same data at a per-character level so that
+ * character-rearranging operations (e.g. BiDi) preserve formatting.
+ * Text is represented as:
+ * - A string of characters
+ * - A matching array of indices, pointing to:
+ * - An array of SectionsOptions, representing the evaluated formatting
+ *    options of the original sections.
+ *
+ * Once the guts of a TaggedString have been re-arranged by BiDi, you can
+ * iterate over the contents in order, using getCharCodeAt and getSection
+ * to get the formatting options for each character in turn.
+ */
+/// maplibre/maplibre-native#4add9ea original name: TaggedString
+#[derive(Clone)]
+pub struct TaggedString {
+    pub styled_text: StyledText,
+    pub sections: Vec<SectionOptions>,
+    pub supports_vertical_writing_mode: Option<bool>,
+    // Max number of images within a text is 6400 U+E000–U+F8FF
+    // that covers Basic Multilingual Plane Unicode Private Use Area (PUA).
+    pub image_section_id: Char16,
+}
+
+impl Default for TaggedString {
+    /// Returns an empty string
+    /// maplibre/maplibre-native#4add9ea original name: default
+    fn default() -> Self {
+        Self {
+            styled_text: (U16String::new(), vec![]), // TODO is this correct?
+            sections: vec![],
+            supports_vertical_writing_mode: None,
+            image_section_id: 0 as Char16, // TODO is this correct?
+        }
+    }
+}
+
+impl TaggedString {
+    /// maplibre/maplibre-native#4add9ea original name: new_from_raw
+    pub fn new_from_raw(text_: U16String, options: SectionOptions) -> Self {
+        let text_len = text_.len();
+        Self {
+            styled_text: (text_, vec![0; text_len]), // TODO is this correct?
+            sections: vec![options],
+            supports_vertical_writing_mode: None,
+            image_section_id: 0 as Char16, // TODO is this correct?
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: new
+    pub fn new(styled_text: StyledText, sections_: Vec<SectionOptions>) -> Self {
+        Self {
+            styled_text,
+            sections: sections_,
+            supports_vertical_writing_mode: None,
+            image_section_id: 0 as Char16, // TODO is this correct?
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: length
+    pub fn length(&self) -> usize {
+        self.styled_text.0.len()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: sectionCount
+    pub fn section_count(&self) -> usize {
+        self.sections.len()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: empty
+    pub fn empty(&self) -> bool {
+        self.styled_text.0.is_empty()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getSection
+    pub fn get_section(&self, index: usize) -> &SectionOptions {
+        &self.sections[self.styled_text.1[index] as usize] // TODO Index does not honor encoding, fine? previously it was .at()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getCharCodeAt
+    pub fn get_char_code_at(&self, index: usize) -> u16 {
+        return self.styled_text.0.as_slice()[index];
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: rawText
+    pub fn raw_text(&self) -> &U16String {
+        &self.styled_text.0
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getStyledText
+    pub fn get_styled_text(&self) -> &StyledText {
+        &self.styled_text
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: addTextSection
+    pub fn add_text_section(
+        &mut self,
+        section_text: &U16String,
+        scale: f64,
+        font_stack: FontStack,
+        text_color: Option<Color>,
+    ) {
+        self.styled_text.0.push(section_text);
+        self.sections
+            .push(SectionOptions::new(scale, font_stack, text_color));
+        self.styled_text
+            .1
+            .resize(self.styled_text.0.len(), (self.sections.len() - 1) as u8);
+        self.supports_vertical_writing_mode = None;
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: addImageSection
+    pub fn add_image_section(&mut self, image_id: String) {
+        let next_image_section_char_code = self.get_next_image_section_char_code();
+
+        if let Some(next_image_section_char_code) = next_image_section_char_code {
+            self.styled_text
+                .0
+                .push(U16Str::from_slice(&[next_image_section_char_code])); // TODO is this correct?
+            self.sections.push(SectionOptions::from_image_id(image_id));
+            self.styled_text
+                .1
+                .resize(self.styled_text.0.len(), (self.sections.len() - 1) as u8);
+        } else {
+            log::warn!("Exceeded maximum number of images in a label.");
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: sectionAt
+    pub fn section_at(&self, index: usize) -> &SectionOptions {
+        &self.sections[index]
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getSections
+    pub fn get_sections(&self) -> &Vec<SectionOptions> {
+        &self.sections
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getSectionIndex
+    pub fn get_section_index(&self, character_index: usize) -> u8 {
+        self.styled_text.1[character_index] // TODO Index does not honor encoding, fine? previously it was .at()
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: getMaxScale
+    pub fn get_max_scale(&self) -> f64 {
+        let mut max_scale: f64 = 0.0;
+        for i in 0..self.styled_text.0.len() {
+            max_scale = max_scale.max(self.get_section(i).scale)
+        }
+        max_scale
+    }
+
+    const WHITESPACE_CHARS: &'static [Char16] = &[
+        ' ' as Char16,
+        '\t' as Char16,
+        '\n' as Char16,
+        BACKSLACK_V as Char16,
+        BACKSLACK_F as Char16,
+        '\r' as Char16,
+    ];
+
+    /// maplibre/maplibre-native#4add9ea original name: trim
+    pub fn trim(&mut self) {
+        let beginning_whitespace: Option<usize> = self
+            .styled_text
+            .0
+            .as_slice()
+            .iter()
+            .position(|c| !Self::WHITESPACE_CHARS.contains(c));
+
+        if let Some(beginning_whitespace) = beginning_whitespace {
+            let trailing_whitespace: usize = self
+                .styled_text
+                .0
+                .as_slice()
+                .iter()
+                .rposition(|c| !Self::WHITESPACE_CHARS.contains(c))
+                .expect("there is a whitespace char")
+                + 1;
+
+            self.styled_text.0 =
+                U16String::from(&self.styled_text.0[beginning_whitespace..trailing_whitespace]); // TODO write test for this
+            self.styled_text.1 =
+                Vec::from(&self.styled_text.1[beginning_whitespace..trailing_whitespace]);
+        } else {
+            // Entirely whitespace
+            self.styled_text.0.clear();
+            self.styled_text.1.clear();
+        }
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: verticalizePunctuation
+    pub fn verticalize_punctuation(&mut self) {
+        // Relies on verticalization changing characters in place so that style indices don't need updating
+        self.styled_text.0 = i18n::verticalize_punctuation_str(&self.styled_text.0);
+    }
+    /// maplibre/maplibre-native#4add9ea original name: allowsVerticalWritingMode
+    pub fn allows_vertical_writing_mode(&mut self) -> bool {
+        if self.supports_vertical_writing_mode.is_none() {
+            let new_value = i18n::allows_vertical_writing_mode(self.raw_text());
+            self.supports_vertical_writing_mode = Some(new_value);
+            return new_value;
+        }
+        self.supports_vertical_writing_mode
+            .expect("supportsVerticalWritingMode mut be set")
+    }
+}
+
+impl TaggedString {
+    /// maplibre/maplibre-native#4add9ea original name: getNextImageSectionCharCode
+    fn get_next_image_section_char_code(&mut self) -> Option<Char16> {
+        if self.image_section_id == 0 {
+            self.image_section_id = PUABEGIN;
+            return Some(self.image_section_id);
+        }
+
+        self.image_section_id += 1;
+        if self.image_section_id > PUAEND {
+            return None;
+        }
+
+        Some(self.image_section_id)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use widestring::U16String;
+
+    use crate::legacy::{
+        bidi::Char16,
+        tagged_string::{SectionOptions, TaggedString},
+        util::i18n::BACKSLACK_V,
+    };
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: TaggedString_Trim
+    fn tagged_string_trim() {
+        let mut basic = TaggedString::new_from_raw(
+            " \t\ntrim that and not this  \n\t".into(),
+            SectionOptions::new(1.0, vec![], None),
+        );
+        basic.trim();
+        assert_eq!(basic.raw_text(), &U16String::from("trim that and not this"));
+
+        let mut two_sections = TaggedString::default();
+        two_sections.add_text_section(&" \t\ntrim that".into(), 1.5, vec![], None);
+        two_sections.add_text_section(&" and not this  \n\t".into(), 0.5, vec![], None);
+
+        two_sections.trim();
+        assert_eq!(
+            two_sections.raw_text(),
+            &U16String::from("trim that and not this")
+        );
+
+        let mut empty = TaggedString::new_from_raw(
+            format!(
+                "\n\t{} \r  \t\n",
+                char::from_u32(BACKSLACK_V as u32).unwrap()
+            )
+            .into(),
+            SectionOptions::new(1.0, vec![], None),
+        );
+        empty.trim();
+        assert_eq!(empty.raw_text(), &U16String::from(""));
+
+        let mut no_trim =
+            TaggedString::new_from_raw("no trim!".into(), SectionOptions::new(1.0, vec![], None));
+        no_trim.trim();
+        assert_eq!(no_trim.raw_text(), &U16String::from("no trim!"));
+    }
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: TaggedString_ImageSections
+    fn tagged_string_image_sections() {
+        let mut string = TaggedString::new_from_raw(U16String::new(), SectionOptions::default());
+        string.add_image_section("image_name".to_string());
+        assert_eq!(string.raw_text(), &U16String::from("\u{E000}"));
+        assert!(string.get_section(0).image_id.is_some());
+        assert_eq!(
+            string.get_section(0).image_id.as_ref().unwrap(),
+            &"image_name".to_string()
+        );
+
+        let mut max_sections = TaggedString::default();
+        for i in 0..6401 {
+            max_sections.add_image_section(i.to_string());
+        }
+
+        assert_eq!(max_sections.get_sections().len(), 6400);
+        assert_eq!(max_sections.get_char_code_at(0), '\u{E000}' as Char16);
+        assert_eq!(max_sections.get_char_code_at(6399), '\u{F8FF}' as Char16);
+    }
+}
diff --git a/maplibre/src/legacy/util/constants.rs b/maplibre/src/legacy/util/constants.rs
new file mode 100644
index 000000000..bd1322e22
--- /dev/null
+++ b/maplibre/src/legacy/util/constants.rs
@@ -0,0 +1,4 @@
+//! Translated (partially) from https://github.com/maplibre/maplibre-native/blob/4add9ea/include/mbgl/util/constants.hpp
+
+// ONE_EM constant used to go between "em" units used in style spec and "points" used internally for layout.
+pub const ONE_EM: f64 = 24.0;
diff --git a/maplibre/src/legacy/util/geo.rs b/maplibre/src/legacy/util/geo.rs
new file mode 100644
index 000000000..9cd69ba42
--- /dev/null
+++ b/maplibre/src/legacy/util/geo.rs
@@ -0,0 +1,6 @@
+//! Translated (partially) from https://github.com/maplibre/maplibre-native/blob/4add9ea/include/mbgl/util/geo.hpp
+
+use geo_types::LineString;
+
+/// maplibre/maplibre-native#4add9ea original name: ScreenLineString
+pub type ScreenLineString = LineString;
diff --git a/maplibre/src/legacy/util/i18n.rs b/maplibre/src/legacy/util/i18n.rs
new file mode 100644
index 000000000..58add6232
--- /dev/null
+++ b/maplibre/src/legacy/util/i18n.rs
@@ -0,0 +1,134 @@
+//! Translated from https://github.com/maplibre/maplibre-native/blob/4add9ea/src/mbgl/util/i18n.cpp
+
+use widestring::U16String;
+
+use crate::legacy::bidi::Char16;
+
+/// maplibre/maplibre-native#4add9ea original name: allowsWordBreaking
+pub fn allows_word_breaking(chr: Char16) -> bool {
+    chr == 0x0a      /* newline */
+        || chr == 0x20   /* space */
+        || chr == 0x26   /* ampersand */
+        || chr == 0x28   /* open parenthesis */
+        || chr == 0x29   /* close parenthesis */
+        || chr == 0x2b   /* plus sign */
+        || chr == 0x2d   /* hyphen-minus */
+        || chr == 0x2f   /* solidus */
+        || chr == 0xad   /* soft hyphen */
+        || chr == 0xb7   /* middle dot */
+        || chr == 0x200b /* zero-width space */
+        || chr == 0x2010 /* hyphen */
+        || chr == 0x2013
+}
+
+/// maplibre/maplibre-native#4add9ea original name: charAllowsLetterSpacing
+pub fn char_allows_letter_spacing(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: allowsLetterSpacing
+pub fn allows_letter_spacing(string: &U16String) -> bool {
+    return false;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: allowsIdeographicBreaking_str
+pub fn allows_ideographic_breaking_str(string: &U16String) -> bool {
+    return false;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: allowsIdeographicBreaking
+pub fn allows_ideographic_breaking(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: allowsFixedWidthGlyphGeneration
+pub fn allows_fixed_width_glyph_generation(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: allowsVerticalWritingMode
+pub fn allows_vertical_writing_mode(string: &U16String) -> bool {
+    return false;
+    todo!()
+}
+
+// The following logic comes from
+// <http://www.unicode.org/Public/12.0.0/ucd/VerticalOrientation.txt>.
+// Keep it synchronized with
+// <http://www.unicode.org/Public/UCD/latest/ucd/VerticalOrientation.txt>.
+// The data file denotes with “U” or “Tu” any codepoint that may be drawn
+// upright in vertical text but does not distinguish between upright and
+// “neutral” characters.
+
+/// maplibre/maplibre-native#4add9ea original name: hasUprightVerticalOrientation
+pub fn has_upright_vertical_orientation(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: hasNeutralVerticalOrientation
+pub fn has_neutral_vertical_orientation(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: hasRotatedVerticalOrientation
+pub fn has_rotated_vertical_orientation(chr: Char16) -> bool {
+    !(has_upright_vertical_orientation(chr) || has_neutral_vertical_orientation(chr))
+}
+
+// Replaces "horizontal" with "vertical" punctuation in place
+// Does not re-order or change length of string
+// (TaggedString::verticalizePunctuation depends on this behavior)
+/// maplibre/maplibre-native#4add9ea original name: verticalizePunctuation_str
+pub fn verticalize_punctuation_str(input: &U16String) -> U16String {
+    return input.clone();
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: verticalizePunctuation
+pub fn verticalize_punctuation(chr: Char16) -> Char16 {
+    return 0;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: charInSupportedScript
+pub fn char_in_supported_script(chr: Char16) -> bool {
+    return true;
+    todo!()
+}
+
+/// maplibre/maplibre-native#4add9ea original name: isStringInSupportedScript
+pub fn is_string_in_supported_script(input: &str) -> bool {
+    let u16string = U16String::from(input); // TODO: verify if this is correct
+    for chr in u16string.as_slice() {
+        if !char_in_supported_script(*chr) {
+            return false;
+        }
+    }
+    true
+}
+
+/// maplibre/maplibre-native#4add9ea original name: isCharInComplexShapingScript
+pub fn is_char_in_complex_shaping_script(chr: Char16) -> bool {
+    false
+}
+
+pub const BACKSLACK_V: Char16 = '\u{000B}' as Char16;
+pub const BACKSLACK_F: Char16 = '\u{000C}' as Char16;
+
+/// maplibre/maplibre-native#4add9ea original name: isWhitespace
+pub fn is_whitespace(chr: Char16) -> bool {
+    // TODO verify that his is correct \v and \f where not available
+    chr == ' ' as Char16
+        || chr == '\t' as Char16
+        || chr == '\n' as Char16
+        || chr == BACKSLACK_V
+        || chr == BACKSLACK_F
+        || chr == '\r' as Char16
+}
diff --git a/maplibre/src/legacy/util/math.rs b/maplibre/src/legacy/util/math.rs
new file mode 100644
index 000000000..017654599
--- /dev/null
+++ b/maplibre/src/legacy/util/math.rs
@@ -0,0 +1,66 @@
+//! Translated functions from https://github.com/maplibre/maplibre-native/blob/4add9ea/
+//! Likely to be replaced by more generic functions.
+
+use std::f64::consts::PI;
+
+use crate::euclid::{Point2D, Vector2D};
+
+/// maplibre/maplibre-native#4add9ea original name: rotate
+pub fn rotate<U>(a: &Vector2D<f64, U>, angle: f64) -> Vector2D<f64, U> {
+    let cos = angle.cos();
+    let sin = angle.sin();
+    let x = cos * a.x - sin * a.y;
+    let y = sin * a.x + cos * a.y;
+    Vector2D::new(x, y)
+}
+
+/**
+ * @brief Converts degrees to radians
+ *
+ * @param deg Degrees as float.
+ * @return Radians as float.
+ */
+/// maplibre/maplibre-native#4add9ea original name: deg2radf
+pub fn deg2radf(deg: f64) -> f64 {
+    deg * PI / 180.0
+}
+
+/// maplibre/maplibre-native#4add9ea original name: perp
+pub fn perp<U>(a: &Vector2D<f64, U>) -> Vector2D<f64, U> {
+    Vector2D::new(-a.y, a.x)
+}
+
+pub trait MinMax<T> {
+    /// maplibre/maplibre-native#4add9ea original name: max_value
+    fn max_value(self) -> T;
+    /// maplibre/maplibre-native#4add9ea original name: min_value
+    fn min_value(self) -> T;
+}
+
+impl MinMax<f64> for [f64; 4] {
+    /// maplibre/maplibre-native#4add9ea original name: max_value
+    fn max_value(self) -> f64 {
+        *self
+            .iter()
+            .max_by(|a, b| a.total_cmp(b))
+            .expect("array is not empty")
+    }
+
+    /// maplibre/maplibre-native#4add9ea original name: min_value
+    fn min_value(self) -> f64 {
+        *self
+            .iter()
+            .min_by(|a, b| a.total_cmp(b))
+            .expect("array is not empty")
+    }
+}
+
+/// maplibre/maplibre-native#4add9ea original name: convert_point_f64
+pub fn convert_point_f64<U>(point: &Point2D<i16, U>) -> Point2D<f64, U> {
+    Point2D::new(point.x as f64, point.y as f64)
+}
+
+/// maplibre/maplibre-native#4add9ea original name: convert_point_i16
+pub fn convert_point_i16<U>(point: &Point2D<f64, U>) -> Point2D<i16, U> {
+    Point2D::new(point.x as i16, point.y as i16)
+}
diff --git a/maplibre/src/legacy/util/mod.rs b/maplibre/src/legacy/util/mod.rs
new file mode 100644
index 000000000..6a5e05aac
--- /dev/null
+++ b/maplibre/src/legacy/util/mod.rs
@@ -0,0 +1,71 @@
+use std::{
+    hash::{DefaultHasher, Hash, Hasher},
+    ops::Range,
+};
+
+pub mod constants;
+pub mod geo;
+pub mod i18n;
+pub mod math;
+
+/// maplibre/maplibre-native#4add9ea original name: hash_combine
+pub fn hash_combine<T: Hash>(seed: &mut u64, v: &T) {
+    let mut hasher = DefaultHasher::new(); // TODO previously used std::hash https://en.cppreference.com/w/cpp/utility/hash
+    v.hash(&mut hasher);
+    *seed ^= hasher
+        .finish()
+        .overflowing_add(0x9e3779b9)
+        .0
+        .overflowing_add(*seed << 6)
+        .0
+        .overflowing_add(*seed >> 2)
+        .0;
+}
+
+/// maplibre/maplibre-native#4add9ea original name: hash
+pub fn hash<T: Hash>(args: &[T]) -> u64 {
+    let mut seed = 0;
+
+    for arg in args {
+        hash_combine(&mut seed, arg);
+    }
+    seed
+}
+
+/// maplibre/maplibre-native#4add9ea original name: split_in_half
+fn split_in_half(range: &Range<usize>) -> (Range<usize>, Range<usize>) {
+    let mid = (range.end - range.start) / 2 + range.start;
+
+    ((range.start..mid), (mid..range.end))
+}
+
+/// maplibre/maplibre-native#4add9ea original name: lower_bound
+pub fn lower_bound<T: PartialOrd>(v: &[T], elt: &T) -> usize {
+    let mut range = 0..v.len();
+    while !range.is_empty() {
+        let (a, b) = split_in_half(&range);
+        if v[b.start] < *elt {
+            range = b.start + 1..b.end;
+        } else {
+            range = a;
+        }
+    }
+    range.start
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::legacy::util::lower_bound;
+
+    #[test]
+    /// maplibre/maplibre-native#4add9ea original name: lower_bound_test
+    fn lower_bound_test() {
+        let mut input = [10, 20, 30, 30, 20, 10, 10, 20];
+
+        input.sort();
+
+        assert_eq!(lower_bound(&input, &20), 3);
+        assert_eq!(lower_bound(&input, &15), 3);
+        assert_eq!(lower_bound(&input, &5), 0);
+    }
+}
diff --git a/maplibre/src/lib.rs b/maplibre/src/lib.rs
index 44cb089a8..e879b88f7 100644
--- a/maplibre/src/lib.rs
+++ b/maplibre/src/lib.rs
@@ -23,8 +23,9 @@ extern crate core;
 // Export tile format
 pub use geozero::mvt::tile; // Used in transferables.rs in web/singlethreaded
 
-// Internal modules
-pub(crate) mod tessellation;
+pub mod euclid {
+    pub use lyon::geom::euclid::*;
+}
 
 pub mod context;
 pub mod coords;
@@ -56,3 +57,6 @@ pub mod tcs;
 pub mod debug;
 pub mod raster;
 pub mod vector;
+
+mod legacy;
+pub mod sdf;
diff --git a/maplibre/src/map.rs b/maplibre/src/map.rs
index b3af9b294..d18d315c9 100644
--- a/maplibre/src/map.rs
+++ b/maplibre/src/map.rs
@@ -16,7 +16,7 @@ use crate::{
         graph::RenderGraphError,
         view_state::ViewState,
     },
-    schedule::{Schedule, Stage},
+    schedule::{Schedule, Stage, StageError},
     style::Style,
     tcs::world::World,
     window::{HeadedMapWindow, MapWindow, MapWindowConfig, WindowCreateError},
@@ -35,6 +35,8 @@ pub enum MapError {
     DeviceInit(RenderError),
     #[error("creating window failed")]
     Window(#[from] WindowCreateError),
+    #[error("executing stage must not error")]
+    StageError(#[from] StageError),
 }
 
 pub enum CurrentMapContext {
@@ -174,7 +176,7 @@ where
     pub fn run_schedule(&mut self) -> Result<(), MapError> {
         match &mut self.map_context {
             CurrentMapContext::Ready(map_context) => {
-                self.schedule.run(map_context);
+                self.schedule.run(map_context)?;
                 Ok(())
             }
             CurrentMapContext::Pending { .. } => Err(MapError::RendererNotReady),
diff --git a/maplibre/src/platform/mod.rs b/maplibre/src/platform/mod.rs
index 7f7794f35..5ddcc1092 100644
--- a/maplibre/src/platform/mod.rs
+++ b/maplibre/src/platform/mod.rs
@@ -3,6 +3,8 @@
 
 #[cfg(not(target_arch = "wasm32"))]
 pub use noweb::run_multithreaded;
+#[cfg(feature = "trace")]
+pub use noweb::trace;
 #[cfg(not(target_arch = "wasm32"))]
 pub use noweb::ReqwestOffscreenKernelEnvironment;
 
diff --git a/maplibre/src/raster/populate_world_system.rs b/maplibre/src/raster/populate_world_system.rs
index fb3533bdf..c98dcfd9a 100644
--- a/maplibre/src/raster/populate_world_system.rs
+++ b/maplibre/src/raster/populate_world_system.rs
@@ -9,7 +9,7 @@ use crate::{
         transferables::{LayerRaster, LayerRasterMissing, RasterTransferables},
         RasterLayerData, RasterLayersDataComponent,
     },
-    tcs::system::System,
+    tcs::system::{System, SystemResult},
 };
 
 pub struct PopulateWorldSystem<E: Environment, T> {
@@ -31,7 +31,7 @@ impl<E: Environment, T: RasterTransferables> System for PopulateWorldSystem<E, T
         "populate_world_system".into()
     }
 
-    fn run(&mut self, MapContext { world, .. }: &mut MapContext) {
+    fn run(&mut self, MapContext { world, .. }: &mut MapContext) -> SystemResult {
         for message in self.kernel.apc().receive(|message| {
             message.has_tag(T::LayerRaster::message_tag())
                 || message.has_tag(T::LayerRasterMissing::message_tag())
@@ -63,5 +63,7 @@ impl<E: Environment, T: RasterTransferables> System for PopulateWorldSystem<E, T
                     .push(RasterLayerData::Missing(message.to_layer()));
             }
         }
+
+        Ok(())
     }
 }
diff --git a/maplibre/src/raster/queue_system.rs b/maplibre/src/raster/queue_system.rs
index ec3425aeb..e08a59a67 100644
--- a/maplibre/src/raster/queue_system.rs
+++ b/maplibre/src/raster/queue_system.rs
@@ -9,15 +9,18 @@ use crate::{
         render_phase::{DrawState, LayerItem, RenderPhase, TileMaskItem},
         tile_view_pattern::WgpuTileViewPattern,
     },
-    tcs::tiles::Tile,
+    tcs::{
+        system::{SystemError, SystemResult},
+        tiles::Tile,
+    },
 };
 
-pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
+pub fn queue_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
     let Some((Initialized(tile_view_pattern),)) = world
         .resources
         .query::<(&Eventually<WgpuTileViewPattern>,)>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     let mut items = Vec::new();
@@ -52,11 +55,13 @@ pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
         .resources
         .query_mut::<(&mut RenderPhase<LayerItem>, &mut RenderPhase<TileMaskItem>)>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     for (layer, mask) in items {
         layer_item_phase.add(layer);
         tile_mask_phase.add(mask);
     }
+
+    Ok(())
 }
diff --git a/maplibre/src/raster/request_system.rs b/maplibre/src/raster/request_system.rs
index 410d73b1f..af894fe02 100644
--- a/maplibre/src/raster/request_system.rs
+++ b/maplibre/src/raster/request_system.rs
@@ -15,9 +15,9 @@ use crate::{
         transferables::{LayerRasterMissing, RasterTransferables},
         RasterLayersDataComponent,
     },
-    render::tile_view_pattern::DEFAULT_TILE_SIZE,
+    render::{tile_view_pattern::DEFAULT_TILE_SIZE, view_state::ViewStatePadding},
     style::layer::LayerPaint,
-    tcs::system::System,
+    tcs::system::{System, SystemResult},
 };
 
 pub struct RequestSystem<E: Environment, T: RasterTransferables> {
@@ -47,9 +47,11 @@ impl<E: Environment, T: RasterTransferables> System for RequestSystem<E, T> {
             world,
             ..
         }: &mut MapContext,
-    ) {
-        let view_region =
-            view_state.create_view_region(view_state.zoom().zoom_level(DEFAULT_TILE_SIZE));
+    ) -> SystemResult {
+        let view_region = view_state.create_view_region(
+            view_state.zoom().zoom_level(DEFAULT_TILE_SIZE),
+            ViewStatePadding::Loose,
+        );
 
         if view_state.did_camera_change() || view_state.did_zoom_change() {
             if let Some(view_region) = &view_region {
@@ -72,7 +74,7 @@ impl<E: Environment, T: RasterTransferables> System for RequestSystem<E, T> {
                     world
                         .tiles
                         .spawn_mut(coords)
-                        .unwrap()
+                        .expect("unable to spawn a raster tile")
                         .insert(RasterLayersDataComponent::default());
 
                     tracing::event!(tracing::Level::ERROR, %coords, "tile request started: {coords}");
@@ -93,12 +95,14 @@ impl<E: Environment, T: RasterTransferables> System for RequestSystem<E, T> {
                                 >>::Context,
                             >,
                         )
-                        .unwrap(); // TODO: Remove unwrap
+                        .expect("unable to call APC"); // TODO: Remove unwrap
                 }
             }
         }
 
         view_state.update_references();
+
+        Ok(())
     }
 }
 pub fn fetch_raster_apc<K: OffscreenKernel, T: RasterTransferables, C: Context + Clone + Send>(
diff --git a/maplibre/src/raster/resource_system.rs b/maplibre/src/raster/resource_system.rs
index 6797ffba6..c4bdac224 100644
--- a/maplibre/src/raster/resource_system.rs
+++ b/maplibre/src/raster/resource_system.rs
@@ -10,6 +10,7 @@ use crate::{
         shaders::Shader,
         RenderResources, Renderer,
     },
+    tcs::system::{SystemError, SystemResult},
 };
 
 pub fn resource_system(
@@ -24,16 +25,16 @@ pub fn resource_system(
             },
         ..
     }: &mut MapContext,
-) {
+) -> SystemResult {
     let Some(raster_resources) = world
         .resources
         .query_mut::<&mut Eventually<RasterResources>>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     raster_resources.initialize(|| {
-        let shader = shaders::RasterTileShader {
+        let shader = shaders::RasterShader {
             format: surface.surface_format(),
         };
 
@@ -51,9 +52,11 @@ pub fn resource_system(
                 false,
                 surface.is_multisampling_supported(settings.msaa),
                 true,
+                false,
             )
             .describe_render_pipeline()
             .initialize(device),
         )
     });
+    Ok(())
 }
diff --git a/maplibre/src/raster/upload_system.rs b/maplibre/src/raster/upload_system.rs
index f047e1ab4..5d4e5cb4c 100644
--- a/maplibre/src/raster/upload_system.rs
+++ b/maplibre/src/raster/upload_system.rs
@@ -9,10 +9,14 @@ use crate::{
     render::{
         eventually::{Eventually, Eventually::Initialized},
         tile_view_pattern::DEFAULT_TILE_SIZE,
+        view_state::ViewStatePadding,
         Renderer,
     },
     style::Style,
-    tcs::tiles::Tiles,
+    tcs::{
+        system::{SystemError, SystemResult},
+        tiles::Tiles,
+    },
 };
 
 pub fn upload_system(
@@ -23,15 +27,17 @@ pub fn upload_system(
         renderer: Renderer { device, queue, .. },
         ..
     }: &mut MapContext,
-) {
+) -> SystemResult {
     let Some(Initialized(raster_resources)) = world
         .resources
         .query_mut::<&mut Eventually<RasterResources>>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
-    let view_region =
-        view_state.create_view_region(view_state.zoom().zoom_level(DEFAULT_TILE_SIZE));
+    let view_region = view_state.create_view_region(
+        view_state.zoom().zoom_level(DEFAULT_TILE_SIZE),
+        ViewStatePadding::Loose,
+    );
 
     if let Some(view_region) = &view_region {
         upload_raster_layer(
@@ -43,6 +49,8 @@ pub fn upload_system(
             view_region,
         );
     }
+
+    Ok(())
 }
 
 #[tracing::instrument(skip_all)]
diff --git a/maplibre/src/render/camera.rs b/maplibre/src/render/camera.rs
index 50f5180b1..7adeec861 100644
--- a/maplibre/src/render/camera.rs
+++ b/maplibre/src/render/camera.rs
@@ -61,6 +61,14 @@ impl ModelViewProjection {
             .cast::<f32>()
             .expect("Unable to cast view projection to f32")
     }
+
+    pub fn get(&self) -> Matrix4<f64> {
+        self.0
+    }
+
+    pub fn project(&self, vector: Vector4<f64>) -> Vector4<f64> {
+        self.0 * vector
+    }
 }
 
 const MIN_PITCH: Deg<f64> = Deg(-30.0);
@@ -205,6 +213,7 @@ impl EdgeInsets {
     }
 }
 
+#[derive(Clone)]
 pub struct Perspective {
     fovy: Rad<f64>,
 }
diff --git a/maplibre/src/render/eventually.rs b/maplibre/src/render/eventually.rs
index 51a5e44af..d039dc2e7 100644
--- a/maplibre/src/render/eventually.rs
+++ b/maplibre/src/render/eventually.rs
@@ -47,10 +47,15 @@ where
 }
 impl<T> Eventually<T> {
     #[tracing::instrument(name = "initialize", skip_all)]
-    pub fn initialize(&mut self, f: impl FnOnce() -> T) {
+    pub fn initialize(&mut self, f: impl FnOnce() -> T) -> &mut T {
         if let Eventually::Uninitialized = self {
             *self = Eventually::Initialized(f());
         }
+
+        match self {
+            Eventually::Initialized(data) => data,
+            Eventually::Uninitialized => panic!("not initialized"),
+        }
     }
 
     pub fn take(&mut self) -> Eventually<T> {
diff --git a/maplibre/src/render/main_pass.rs b/maplibre/src/render/main_pass.rs
index a7945eb95..57c6b4f24 100644
--- a/maplibre/src/render/main_pass.rs
+++ b/maplibre/src/render/main_pass.rs
@@ -94,6 +94,8 @@ impl Node for MainPassNode {
 
         let mut tracked_pass = TrackedRenderPass::new(render_pass);
 
+        // TODO: Automatically raise error when items get linearly too many (+1k)
+
         if let Some(mask_items) = world.resources.get::<RenderPhase<TileMaskItem>>() {
             log::trace!("RenderPhase<TileMaskItem>::size() = {}", mask_items.size());
             for item in mask_items {
diff --git a/maplibre/src/render/mod.rs b/maplibre/src/render/mod.rs
index 870dd6f34..bff2f955a 100644
--- a/maplibre/src/render/mod.rs
+++ b/maplibre/src/render/mod.rs
@@ -52,7 +52,8 @@ mod systems;
 // Rendering internals
 mod graph_runner;
 mod main_pass;
-pub mod shaders; // TODO: Make private
+pub mod shaders;
+mod translucent_pass; // TODO: Make private
 
 // Public API
 pub mod builder;
@@ -69,9 +70,10 @@ pub use shaders::ShaderVertex;
 
 use crate::{
     render::{
-        render_phase::{LayerItem, RenderPhase, TileMaskItem},
+        render_phase::{LayerItem, RenderPhase, TileMaskItem, TranslucentItem},
         systems::{graph_runner_system::GraphRunnerSystem, upload_system::upload_system},
         tile_view_pattern::{ViewTileSources, WgpuTileViewPattern},
+        translucent_pass::TranslucentPassNode,
     },
     window::PhysicalSize,
 };
@@ -544,6 +546,7 @@ mod draw_graph {
     // Labels for non-input nodes
     pub mod node {
         pub const MAIN_PASS: &str = "main_pass";
+        pub const TRANSLUCENT_PASS: &str = "translucent_pass";
     }
 }
 
@@ -573,12 +576,23 @@ impl<E: Environment> Plugin<E> for RenderPlugin {
         let mut draw_graph = RenderGraph::default();
         // Draw nodes
         draw_graph.add_node(draw_graph::node::MAIN_PASS, MainPassNode::new());
+        // Draw nodes
+        draw_graph.add_node(
+            draw_graph::node::TRANSLUCENT_PASS,
+            TranslucentPassNode::new(),
+        );
         // Input node
         let input_node_id = draw_graph.set_input(vec![]);
         // Edges
         draw_graph
             .add_node_edge(input_node_id, draw_graph::node::MAIN_PASS)
             .expect("main pass or draw node does not exist");
+        draw_graph
+            .add_node_edge(
+                draw_graph::node::MAIN_PASS,
+                draw_graph::node::TRANSLUCENT_PASS,
+            )
+            .expect("main pass or draw node does not exist");
 
         graph.add_sub_graph(draw_graph::NAME, draw_graph);
         graph.add_node(main_graph::node::MAIN_PASS_DEPENDENCIES, EmptyNode);
@@ -593,6 +607,7 @@ impl<E: Environment> Plugin<E> for RenderPlugin {
         // render graph dependency
         resources.init::<RenderPhase<LayerItem>>();
         resources.init::<RenderPhase<TileMaskItem>>();
+        resources.init::<RenderPhase<TranslucentItem>>();
         // tile_view_pattern:
         resources.insert(Eventually::<WgpuTileViewPattern>::Uninitialized);
         resources.init::<ViewTileSources>();
diff --git a/maplibre/src/render/render_phase/mod.rs b/maplibre/src/render/render_phase/mod.rs
index fe5b5c7ad..24275601e 100644
--- a/maplibre/src/render/render_phase/mod.rs
+++ b/maplibre/src/render/render_phase/mod.rs
@@ -68,6 +68,28 @@ impl PhaseItem for LayerItem {
     }
 }
 
+pub struct TranslucentItem {
+    pub draw_function: Box<dyn Draw<TranslucentItem>>,
+    pub index: u32,
+
+    pub style_layer: String,
+
+    pub tile: Tile,
+    pub source_shape: TileShape, // FIXME tcs: TileShape contains buffer ranges. This is bad, move them to a component?
+}
+
+impl PhaseItem for TranslucentItem {
+    type SortKey = u32;
+
+    fn sort_key(&self) -> Self::SortKey {
+        self.index
+    }
+
+    fn draw_function(&self) -> &dyn Draw<TranslucentItem> {
+        self.draw_function.as_ref()
+    }
+}
+
 pub struct TileMaskItem {
     pub draw_function: Box<dyn Draw<TileMaskItem>>,
     pub source_shape: TileShape,
diff --git a/maplibre/src/render/resource/tile_pipeline.rs b/maplibre/src/render/resource/tile_pipeline.rs
index 26c421078..03c6ef50a 100644
--- a/maplibre/src/render/resource/tile_pipeline.rs
+++ b/maplibre/src/render/resource/tile_pipeline.rs
@@ -18,6 +18,7 @@ pub struct TilePipeline {
     wireframe: bool,
     msaa: bool,
     raster: bool,
+    glyph_rendering: bool,
     settings: RendererSettings,
 
     vertex_state: VertexState,
@@ -36,6 +37,7 @@ impl TilePipeline {
         wireframe: bool,
         multisampling: bool,
         raster: bool,
+        glyph_rendering: bool,
     ) -> Self {
         TilePipeline {
             name,
@@ -45,6 +47,7 @@ impl TilePipeline {
             wireframe,
             msaa: multisampling,
             raster,
+            glyph_rendering,
             settings,
             vertex_state,
             fragment_state,
@@ -95,6 +98,25 @@ impl RenderPipeline for TilePipeline {
                         count: None,
                     },
                 ]])
+            } else if self.glyph_rendering {
+                Some(vec![vec![
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                            multisampled: false,
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                        count: None,
+                    },
+                ]])
             } else {
                 None
             },
diff --git a/maplibre/src/render/shaders/tile.vertex.wgsl b/maplibre/src/render/shaders/fill.vertex.wgsl
similarity index 97%
rename from maplibre/src/render/shaders/tile.vertex.wgsl
rename to maplibre/src/render/shaders/fill.vertex.wgsl
index 749cddad6..04eeb32a3 100644
--- a/maplibre/src/render/shaders/tile.vertex.wgsl
+++ b/maplibre/src/render/shaders/fill.vertex.wgsl
@@ -36,6 +36,7 @@ fn main(
     //}
 
     var final_position = mat4x4<f32>(translate1, translate2, translate3, translate4) * vec4<f32>(position + normal * width, z, 1.0);
+    final_position.z = z_index;
 
     return VertexOutput(color, final_position);
 }
diff --git a/maplibre/src/render/shaders/mod.rs b/maplibre/src/render/shaders/mod.rs
index b9db2a654..8d5be43c0 100644
--- a/maplibre/src/render/shaders/mod.rs
+++ b/maplibre/src/render/shaders/mod.rs
@@ -5,6 +5,7 @@ use cgmath::SquareMatrix;
 
 use crate::{
     coords::WorldCoords,
+    legacy::buckets::symbol_bucket::SymbolVertex,
     render::resource::{FragmentState, VertexBufferLayout, VertexState},
 };
 
@@ -92,14 +93,14 @@ impl Shader for TileMaskShader {
     }
 }
 
-pub struct VectorTileShader {
+pub struct FillShader {
     pub format: wgpu::TextureFormat,
 }
 
-impl Shader for VectorTileShader {
+impl Shader for FillShader {
     fn describe_vertex(&self) -> VertexState {
         VertexState {
-            source: include_str!("tile.vertex.wgsl"),
+            source: include_str!("fill.vertex.wgsl"),
             entry_point: "main",
             buffers: vec![
                 // vertex data
@@ -170,7 +171,7 @@ impl Shader for VectorTileShader {
                 },
                 // features
                 VertexBufferLayout {
-                    array_stride: std::mem::size_of::<ShaderFeatureStyle>() as u64,
+                    array_stride: std::mem::size_of::<FillShaderFeatureMetadata>() as u64,
                     step_mode: wgpu::VertexStepMode::Vertex,
                     attributes: vec![
                         // color
@@ -258,22 +259,22 @@ impl Default for ShaderVertex {
 
 #[repr(C)]
 #[derive(Debug, Copy, Clone, Pod, Zeroable)]
-pub struct ShaderFeatureStyle {
+pub struct FillShaderFeatureMetadata {
     pub color: Vec4f32,
 }
 
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Pod, Zeroable, Default)]
+pub struct SDFShaderFeatureMetadata {
+    pub opacity: f32,
+}
+
 #[repr(C)]
 #[derive(Copy, Clone, Pod, Zeroable)]
 pub struct ShaderLayerMetadata {
     pub z_index: f32,
 }
 
-impl ShaderLayerMetadata {
-    pub fn new(z_index: f32) -> Self {
-        Self { z_index }
-    }
-}
-
 #[repr(C)]
 #[derive(Copy, Clone, Pod, Zeroable)]
 pub struct ShaderTileMetadata {
@@ -312,14 +313,14 @@ impl Default for ShaderTextureVertex {
     }
 }
 
-pub struct RasterTileShader {
+pub struct RasterShader {
     pub format: wgpu::TextureFormat,
 }
 
-impl Shader for RasterTileShader {
+impl Shader for RasterShader {
     fn describe_vertex(&self) -> VertexState {
         VertexState {
-            source: include_str!("tile_raster.vertex.wgsl"),
+            source: include_str!("raster.vertex.wgsl"),
             entry_point: "main",
             buffers: vec![
                 // tile metadata
@@ -375,7 +376,7 @@ impl Shader for RasterTileShader {
 
     fn describe_fragment(&self) -> FragmentState {
         FragmentState {
-            source: include_str!("tile_raster.fragment.wgsl"),
+            source: include_str!("raster.fragment.wgsl"),
             entry_point: "main",
             targets: vec![Some(wgpu::ColorTargetState {
                 format: self.format,
@@ -388,3 +389,180 @@ impl Shader for RasterTileShader {
         }
     }
 }
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+pub struct ShaderSymbolVertex {
+    // 4 bytes * 3 = 12 bytes
+    pub position: [f32; 3],
+    // 4 bytes * 3 = 12 bytes
+    pub text_anchor: [f32; 3],
+    // 4 bytes * 2 = 8 bytes
+    pub tex_coords: [f32; 2],
+    // 1 byte * 4 = 4 bytes
+    pub color: [u8; 4],
+    // 1 byte
+    pub is_glyph: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+pub struct ShaderSymbolVertexNew {
+    pub a_pos_offset: [i32; 4],
+    pub a_data: [u32; 4],
+    pub a_pixeloffset: [i32; 4],
+}
+
+const MAX_GLYPH_ICON_SIZE: u32 = 255;
+const SIZE_PACK_FACTOR: u32 = 128;
+const MAX_PACKED_SIZE: u32 = MAX_GLYPH_ICON_SIZE * SIZE_PACK_FACTOR;
+
+impl ShaderSymbolVertexNew {
+    pub fn new(vertex: &SymbolVertex) -> Self {
+        let a_size_min =
+            (MAX_PACKED_SIZE.min((vertex.size_data.start * SIZE_PACK_FACTOR as f64) as u32) << 1)
+                + vertex.is_sdf as u32;
+        let a_size_max =
+            MAX_PACKED_SIZE.min((vertex.size_data.end * SIZE_PACK_FACTOR as f64) as u32);
+
+        ShaderSymbolVertexNew {
+            a_pos_offset: [
+                vertex.label_anchor.x as i32,
+                vertex.label_anchor.y as i32,
+                (vertex.o.x * 32.).round() as i32,
+                ((vertex.o.y + vertex.glyph_offset_y) * 32.) as i32,
+            ],
+            a_data: [vertex.tx as u32, vertex.ty as u32, a_size_min, a_size_max],
+            a_pixeloffset: [
+                (vertex.pixel_offset.x * 16.) as i32,
+                (vertex.pixel_offset.y * 16.) as i32,
+                (vertex.min_font_scale.x * 256.) as i32,
+                (vertex.min_font_scale.y * 256.) as i32,
+            ],
+        }
+    }
+}
+
+pub struct SymbolShader {
+    pub format: wgpu::TextureFormat,
+}
+
+impl Shader for SymbolShader {
+    fn describe_vertex(&self) -> VertexState {
+        VertexState {
+            source: include_str!("sdf_new.vertex.wgsl"),
+            entry_point: "main",
+            buffers: vec![
+                // vertex data
+                VertexBufferLayout {
+                    array_stride: std::mem::size_of::<ShaderSymbolVertexNew>() as u64,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    attributes: vec![
+                        // a_pos_offset
+                        wgpu::VertexAttribute {
+                            offset: 0,
+                            format: wgpu::VertexFormat::Sint32x4,
+                            shader_location: 0,
+                        },
+                        // a_data
+                        wgpu::VertexAttribute {
+                            offset: wgpu::VertexFormat::Sint32x4.size(),
+                            format: wgpu::VertexFormat::Uint32x4,
+                            shader_location: 1,
+                        },
+                        // a_pixeloffset
+                        wgpu::VertexAttribute {
+                            offset: wgpu::VertexFormat::Sint32x4.size()
+                                + wgpu::VertexFormat::Uint32x4.size(),
+                            format: wgpu::VertexFormat::Sint32x4,
+                            shader_location: 2,
+                        },
+                    ],
+                },
+                // tile metadata
+                VertexBufferLayout {
+                    array_stride: std::mem::size_of::<ShaderTileMetadata>() as u64,
+                    step_mode: wgpu::VertexStepMode::Instance,
+                    attributes: vec![
+                        // translate
+                        wgpu::VertexAttribute {
+                            offset: 0,
+                            format: wgpu::VertexFormat::Float32x4,
+                            shader_location: 4,
+                        },
+                        wgpu::VertexAttribute {
+                            offset: 1 * wgpu::VertexFormat::Float32x4.size(),
+                            format: wgpu::VertexFormat::Float32x4,
+                            shader_location: 5,
+                        },
+                        wgpu::VertexAttribute {
+                            offset: 2 * wgpu::VertexFormat::Float32x4.size(),
+                            format: wgpu::VertexFormat::Float32x4,
+                            shader_location: 6,
+                        },
+                        wgpu::VertexAttribute {
+                            offset: 3 * wgpu::VertexFormat::Float32x4.size(),
+                            format: wgpu::VertexFormat::Float32x4,
+                            shader_location: 7,
+                        },
+                        // zoom_factor
+                        wgpu::VertexAttribute {
+                            offset: 4 * wgpu::VertexFormat::Float32x4.size(),
+                            format: wgpu::VertexFormat::Float32,
+                            shader_location: 9,
+                        },
+                    ],
+                },
+                // layer metadata
+                //VertexBufferLayout {
+                //    array_stride: std::mem::size_of::<ShaderLayerMetadata>() as u64,
+                //    step_mode: wgpu::VertexStepMode::Instance,
+                //    attributes: vec![
+                //        // z_index
+                //        wgpu::VertexAttribute {
+                //            offset: 0,
+                //            format: wgpu::VertexFormat::Float32,
+                //            shader_location: 10,
+                //        },
+                //    ],
+                //},
+                // features
+                //VertexBufferLayout {
+                //    array_stride: std::mem::size_of::<SDFShaderFeatureMetadata>() as u64,
+                //    step_mode: wgpu::VertexStepMode::Vertex,
+                //    attributes: vec![
+                //        // opacity
+                //        wgpu::VertexAttribute {
+                //            offset: 0,
+                //            format: wgpu::VertexFormat::Float32,
+                //            shader_location: 12,
+                //        },
+                //    ],
+                //},
+            ],
+        }
+    }
+
+    fn describe_fragment(&self) -> FragmentState {
+        FragmentState {
+            source: include_str!("sdf_new.fragment.wgsl"),
+            entry_point: "main",
+            targets: vec![Some(wgpu::ColorTargetState {
+                format: self.format,
+                write_mask: wgpu::ColorWrites::ALL,
+                blend: Some(wgpu::BlendState {
+                    color: wgpu::BlendComponent {
+                        src_factor: wgpu::BlendFactor::SrcAlpha,
+                        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                        operation: wgpu::BlendOperation::Add,
+                    },
+                    alpha: wgpu::BlendComponent {
+                        src_factor: wgpu::BlendFactor::One,
+                        dst_factor: wgpu::BlendFactor::Zero,
+                        operation: wgpu::BlendOperation::Add,
+                    },
+                }),
+            })],
+        }
+    }
+}
diff --git a/maplibre/src/render/shaders/tile_raster.fragment.wgsl b/maplibre/src/render/shaders/raster.fragment.wgsl
similarity index 100%
rename from maplibre/src/render/shaders/tile_raster.fragment.wgsl
rename to maplibre/src/render/shaders/raster.fragment.wgsl
diff --git a/maplibre/src/render/shaders/tile_raster.vertex.wgsl b/maplibre/src/render/shaders/raster.vertex.wgsl
similarity index 100%
rename from maplibre/src/render/shaders/tile_raster.vertex.wgsl
rename to maplibre/src/render/shaders/raster.vertex.wgsl
diff --git a/maplibre/src/render/shaders/sdf.fragment.wgsl b/maplibre/src/render/shaders/sdf.fragment.wgsl
new file mode 100644
index 000000000..597afe4d9
--- /dev/null
+++ b/maplibre/src/render/shaders/sdf.fragment.wgsl
@@ -0,0 +1,80 @@
+struct VertexOutput {
+//    @location(0) is_glyph: i32, // Chrome complaints about this line
+    @location(1) tex_coords: vec2<f32>,
+    @location(2) color: vec4<f32>,
+    @location(3) opacity: f32,
+    @builtin(position) position: vec4<f32>,
+};
+
+struct Output {
+    @location(0) out_color: vec4<f32>,
+};
+
+@group(0) @binding(0)
+var t_glyphs: texture_2d<f32>;
+@group(0) @binding(1)
+var s_glyphs: sampler;
+
+// Note: Ensure uniform control flow!
+// https://www.khronos.org/opengl/wiki/Sampler_(GLSL)#Non-uniform_flow_control
+@fragment
+fn main(in: VertexOutput) -> Output {
+    if (in.opacity == 0.0) {
+        // Shortcut if opacity is zero. TODO is this increasing or harming performance?
+        return Output(vec4<f32>(0.0, 0.0, 0.0, 0.0));
+    }
+
+    let buffer_width: f32 = 0.25;
+    let buffer_center_outline: f32 = 0.8;
+
+    // At which offset is the outline of the SDF?
+    let outline_center_offset: f32 = -0.25;
+
+    // shift outline by `outline_width` to the ouside
+    let buffer_center: f32 = buffer_center_outline + outline_center_offset;
+
+    let outline_color = vec3<f32>(0.0, 0.0, 0.0);
+
+    // 0 => border, < 0 => inside, > 0 => outside
+    let dist = textureSample(t_glyphs, s_glyphs, in.tex_coords).r;
+
+    let alpha: f32 = smoothstep(buffer_center - buffer_width / 2.0, buffer_center + buffer_width / 2.0, dist);
+    let border: f32 = smoothstep(buffer_center_outline - buffer_width / 2.0, buffer_center_outline + buffer_width / 2.0, dist);
+
+    let color_rgb = mix(outline_color.rgb, in.color.rgb, border);
+
+    // The translucent pass does not have a depth buffer. Therefore we do not need to discord the fragments:
+    // "Another Good Trick" from https://www.sjbaker.org/steve/omniv/alpha_sorting.html
+    // Using discard is an alternative for GL_ALPHA_TEST.
+    // https://stackoverflow.com/questions/53024693/opengl-is-discard-the-only-replacement-for-deprecated-gl-alpha-test
+
+
+    return Output(vec4(color_rgb, in.color.a * alpha * in.opacity));
+    //return Output(vec4(vec3<f32>(in.opacity, 0.0, 0.0), 0.2)); // debug bounding box, alpha 0.2 to see collisions
+}
+
+
+// MapLibre SDF shader:
+/*
+    let SDF_PX = 8.0;
+    let device_pixel_ratio = 1.0;
+    let EDGE_GAMMA = 0.105 / device_pixel_ratio;
+
+    let size = 6.0; // TODO
+    let font_scale = size / 24.0; // TODO Why / 24?
+    let halo_width = 0.5; // TODO
+    let halo_blur = 0.5; // TODO
+    let halo_color = vec4(1.0, 0.0, 0.0, 1.0);
+
+    var color = in.color;
+    var gamma_scale = 1.0;
+    var gamma = EDGE_GAMMA / (font_scale * gamma_scale);
+    var buff = (256.0 - 64.0) / 256.0;
+
+    let is_halo = false;
+    if (is_halo) {
+        color = halo_color;
+        gamma = (halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (font_scale * gamma_scale);
+        buff = (6.0 - halo_width / font_scale) / SDF_PX;
+    }
+*/
\ No newline at end of file
diff --git a/maplibre/src/render/shaders/sdf.vertex.wgsl b/maplibre/src/render/shaders/sdf.vertex.wgsl
new file mode 100644
index 000000000..cdaccff08
--- /dev/null
+++ b/maplibre/src/render/shaders/sdf.vertex.wgsl
@@ -0,0 +1,37 @@
+
+struct VertexOutput {
+//    @location(0) is_glyph: i32, // Chrome complaints about this line
+    @location(1) tex_coords: vec2<f32>,
+    @location(2) color: vec4<f32>,
+    @location(3) opacity: f32,
+    @builtin(position) position: vec4<f32>,
+};
+
+@vertex
+fn main(
+    @location(0) position: vec3<f32>,
+    @location(1) text_anchor: vec3<f32>,
+    @location(4) translate1: vec4<f32>,
+    @location(5) translate2: vec4<f32>,
+    @location(6) translate3: vec4<f32>,
+    @location(7) translate4: vec4<f32>,
+    @location(9) zoom_factor: f32,
+    @location(10) z_index: f32,
+    @location(11) tex_coords: vec2<f32>,
+    @location(12) opacity: f32,
+    @builtin(instance_index) instance_idx: u32 // instance_index is used when we have multiple instances of the same "object"
+) -> VertexOutput {
+    let font_scale = 6.0;
+
+    let scaling: mat3x3<f32> = mat3x3<f32>(
+            vec3<f32>(zoom_factor * font_scale,   0.0,          0.0),
+            vec3<f32>(0.0,            zoom_factor * font_scale, 0.0),
+            vec3<f32>(0.0,            0.0,         1.0)
+    );
+
+    var final_position = mat4x4<f32>(translate1, translate2, translate3, translate4) * vec4<f32>((scaling * (position - text_anchor) + text_anchor), 1.0);
+    final_position.z = z_index;
+
+    let white = vec4<f32>(1.0, 1.0, 1.0, 1.0);
+    return VertexOutput(tex_coords, white, opacity, final_position);
+}
\ No newline at end of file
diff --git a/maplibre/src/render/shaders/sdf_new.fragment.wgsl b/maplibre/src/render/shaders/sdf_new.fragment.wgsl
new file mode 100644
index 000000000..45d1d2a41
--- /dev/null
+++ b/maplibre/src/render/shaders/sdf_new.fragment.wgsl
@@ -0,0 +1,102 @@
+struct VertexOutput {
+    @location(1) v_data0: vec2<f32>,
+    @location(2) v_data1: vec3<f32>,
+    @builtin(position) position: vec4<f32>,
+};
+
+
+struct Output {
+    @location(0) out_color: vec4<f32>,
+};
+
+@group(0) @binding(0)
+var t_glyphs: texture_2d<f32>;
+@group(0) @binding(1)
+var s_glyphs: sampler;
+
+// Note: Ensure uniform control flow!
+// https://www.khronos.org/opengl/wiki/Sampler_(GLSL)#Non-uniform_flow_control
+@fragment
+fn main(in: VertexOutput) -> Output {
+let SDF_PX:f32 =  8.0;
+
+    let   fill_color: vec4<f32> = vec4<f32>(1.0, 0.0, 0.0, 1.0);  // highp
+    let  halo_color: vec4<f32>= vec4<f32>(0.0, 1.0, 0.0, 1.0);   // highp
+    let   opacity: f32 = 1.0; // lowp
+    let   halo_width: f32 = 1.0; // lowp
+    let   halo_blur: f32 = 1.0; // lowp
+
+let  u_is_halo: bool = false;
+let  u_gamma_scale: f32 = 1.0; // highp
+let  u_device_pixel_ratio: f32 = 1.0; // lowp
+let  u_is_text: bool = true;
+
+let tex: vec2<f32> = in.v_data0.xy;
+
+
+ let EDGE_GAMMA: f32 = 0.105 / u_device_pixel_ratio;
+
+
+    let gamma_scale: f32 = in.v_data1.x;
+    let size: f32 = in.v_data1.y;
+    let fade_opacity: f32 = in.v_data1[2];
+
+    let font_scale: f32 = select(size,  size / 24.0, u_is_text);
+
+    var color: vec4<f32> = fill_color; // lowp
+    var  gamma: f32 = EDGE_GAMMA / (font_scale * u_gamma_scale); // highp
+     var buff = (256.0 - 64.0) / 256.0; // lowp
+    if (u_is_halo) {
+        color = halo_color;
+        gamma = (halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (font_scale * u_gamma_scale);
+        buff = (6.0 - halo_width / font_scale) / SDF_PX;
+    }
+
+     let dist: f32 =  textureSample(t_glyphs, s_glyphs, tex).r; // lowp
+     let gamma_scaled: f32 = gamma * gamma_scale; // highp
+     let alpha: f32 = smoothstep(buff - gamma_scaled, buff + gamma_scaled, dist); // highp
+
+    let fragColor = color * (alpha * opacity * fade_opacity);
+
+
+
+    return Output(fragColor);
+
+
+
+
+}
+
+/*
+ let buffer_width: f32 = 0.25;
+        let buffer_center_outline: f32 = 0.8;
+
+        // At which offset is the outline of the SDF?
+        let outline_center_offset: f32 = -0.25;
+
+        // shift outline by `outline_width` to the ouside
+        let buffer_center: f32 = buffer_center_outline + outline_center_offset;
+
+        let outline_color = vec3<f32>(0.0, 0.0, 0.0);
+
+        // 0 => border, < 0 => inside, > 0 => outside
+        let dist = textureSample(t_glyphs, s_glyphs, tex).r;
+
+        let alpha: f32 = smoothstep(buffer_center - buffer_width / 2.0, buffer_center + buffer_width / 2.0, dist);
+        let border: f32 = smoothstep(buffer_center_outline - buffer_width / 2.0, buffer_center_outline + buffer_width / 2.0, dist);
+
+        let color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
+
+        let color_rgb = mix(outline_color.rgb, color.rgb, border);
+
+        // The translucent pass does not have a depth buffer. Therefore we do not need to discord the fragments:
+        // "Another Good Trick" from https://www.sjbaker.org/steve/omniv/alpha_sorting.html
+        // Using discard is an alternative for GL_ALPHA_TEST.
+        // https://stackoverflow.com/questions/53024693/opengl-is-discard-the-only-replacement-for-deprecated-gl-alpha-test
+
+
+        return Output(vec4(color_rgb, color.a * alpha * 1.0));
+       //   return Output(vec4(vec3<f32>(1.0, 0.0, 0.0), 1.0)); // debug bounding box, alpha 0.2 to see collisions
+*/
+
+
diff --git a/maplibre/src/render/shaders/sdf_new.vertex.wgsl b/maplibre/src/render/shaders/sdf_new.vertex.wgsl
new file mode 100644
index 000000000..3fc12ee91
--- /dev/null
+++ b/maplibre/src/render/shaders/sdf_new.vertex.wgsl
@@ -0,0 +1,138 @@
+
+struct VertexOutput {
+    @location(1) v_data0: vec2<f32>,
+    @location(2) v_data1: vec3<f32>,
+    @builtin(position) position: vec4<f32>,
+};
+
+@vertex
+fn main(
+    @location(0) a_pos_offset: vec4<i32>,
+    @location(1) a_data: vec4<u32>,
+    @location(2) a_pixeloffset: vec4<i32>,
+
+
+
+    @location(4) translate1: vec4<f32>,
+    @location(5) translate2: vec4<f32>,
+    @location(6) translate3: vec4<f32>,
+    @location(7) translate4: vec4<f32>,
+    @location(9) zoom_factor: f32,
+    //@location(10) z_index: f32,
+    //@location(12) opacity: f32,
+    @builtin(instance_index) instance_idx: u32 // instance_index i0 used when we have multiple instances of the same "object"
+) -> VertexOutput {
+
+    let unit: mat4x4<f32> = mat4x4<f32>(
+            vec4<f32>(1.0,   0.0,          0.0,0.0),
+            vec4<f32>(0.0,            1.0, 0.0,0.0),
+            vec4<f32>(0.0,            0.0,         1.0,0.0),
+            vec4<f32>(0.0,            0.0,         0.0,1.0)
+    );
+
+
+// contents of a_size vary based on the type of property value
+// used for {text,icon}-size.
+// For constants, a_size is disabled.
+// For source functions, we bind only one value per vertex: the value of {text,icon}-size evaluated for the current feature.
+// For composite functions:
+// [ text-size(lowerZoomStop, feature),
+//   text-size(upperZoomStop, feature) ]
+let  u_is_size_zoom_constant: bool = true;
+let  u_is_size_feature_constant: bool= true;
+let   u_size_t: f32 = 0.0; // highp // used to interpolate between zoom stops when size is a composite function
+let   u_size: f32 = 30.0; // highp // used when size is both zoom and feature constant
+let u_matrix: mat4x4<f32> = mat4x4<f32>(translate1, translate2, translate3, translate4);
+let u_label_plane_matrix: mat4x4<f32> = unit;
+let u_coord_matrix: mat4x4<f32> = unit;
+let u_is_text: bool = true;
+let u_pitch_with_map: bool = true;
+let  u_pitch: f32= 0.0; // highp
+let u_rotate_symbol: bool = false;
+let   u_aspect_ratio: f32 = 0.0; // highp
+let   u_camera_to_center_distance: f32 = 0.0; // highp
+let u_fade_change: f32 = 0.0;
+let  u_texsize: vec2<f32>= vec2<f32>(3178.0, 30.0);
+
+let a_projected_pos: vec3<f32> =  vec3<f32>(vec2<f32>(a_pos_offset.xy), 0.0);
+
+
+
+
+    let a_pos: vec2<i32> = a_pos_offset.xy;
+    let a_offset: vec2<i32>  = a_pos_offset.zw;
+
+    let a_tex: vec2<u32>  = a_data.xy;
+    let a_size: vec2<u32> = a_data.zw;
+
+    let a_size_min: f32 = floor(f32(a_size[0]) * 0.5);
+    let a_pxoffset: vec2<i32>  = a_pixeloffset.xy;
+
+    let segment_angle: f32 = -a_projected_pos[2]; // highp
+    var  size: f32 = u_size;
+
+    if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {
+        size = mix(a_size_min, f32(a_size[1]), u_size_t) / 128.0;
+    } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {
+        size = a_size_min / 128.0;
+    }
+
+    let projectedPoint: vec4<f32> = u_matrix * vec4(vec2<f32>(a_pos), 0.0, 1.0);
+    let camera_to_anchor_distance: f32 = projectedPoint.w; // highp
+    // If the label is pitched with the map, layout is done in pitched space,
+    // which makes labels in the distance smaller relative to viewport space.
+    // We counteract part of that effect by multiplying by the perspective ratio.
+    // If the label isn't pitched with the map, we do layout in viewport space,
+    // which makes labels in the distance larger relative to the features around
+    // them. We counteract part of that effect by dividing by the perspective ratio.
+    let distance_ratio: f32 = select(
+        u_camera_to_center_distance / camera_to_anchor_distance,
+        camera_to_anchor_distance / u_camera_to_center_distance,
+        u_pitch_with_map
+    ); // highp
+
+     let perspective_ratio: f32 = clamp(
+        0.5 + 0.5 * distance_ratio,
+        0.0, // Prevents oversized near-field symbols in pitched/overzoomed tiles
+        4.0); // highp
+
+    size *= perspective_ratio;
+
+    let font_scale: f32 = select(size,  size / 24.0, u_is_text);
+
+    let symbol_rotation: f32 = 0.0; // highp
+    //if (u_rotate_symbol) {
+    //    // Point labels with 'rotation-alignment: map' are horizontal with respect to tile units
+    //    // To figure out that angle in projected space, we draw a short horizontal line in tile
+    //    // space, project it, and measure its angle in projected space.
+    //    vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);
+
+    //    vec2 a = projectedPoint.xy / projectedPoint.w;
+    //    vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w;
+
+    //    symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x);
+    //}
+
+     let angle_sin: f32 = sin(segment_angle + symbol_rotation); // highp
+     let angle_cos: f32  = cos(segment_angle + symbol_rotation); // highp
+    let rotation_matrix: mat2x2<f32> = mat2x2<f32>(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);
+
+    let projected_pos: vec4<f32> = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);
+    let gl_Position = u_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (vec2<f32>(a_offset) / 32.0 * font_scale + vec2<f32>(a_pxoffset)), 0.0, 1.0);
+    let gamma_scale: f32 = gl_Position.w;
+
+    // TODO let fade_opacity: vec4<f32> = unpack_opacity(a_fade_opacity);
+    let fade_opacity: vec4<f32> = vec4<f32>(1.0,1.0,1.0,1.0);
+    let fade_change: f32  = select(-u_fade_change, u_fade_change, fade_opacity[1] > 0.5);
+    let interpolated_fade_opacity: f32  = max(0.0, min(1.0, fade_opacity[0] + fade_change));
+
+
+    let v_data0: vec2<f32> = vec2<f32>(a_tex) / u_texsize;
+    let v_data1 = vec3<f32>(gamma_scale, size, interpolated_fade_opacity);
+
+
+    //var final_position = mat4x4<f32>(translate1, translate2, translate3, translate4) * vec4<f32>(a_projected_pos + vec3<f32>(vec2<f32>(a_offset) / 32.0 * font_scale + vec2<f32>(a_pxoffset), 0.0), 1.0);
+    var final_position =  mat4x4<f32>(translate1, translate2, translate3, translate4)*gl_Position;
+    final_position.z = 10.0;
+    return VertexOutput(v_data0, v_data1, final_position);
+}
\ No newline at end of file
diff --git a/maplibre/src/render/systems/cleanup_system.rs b/maplibre/src/render/systems/cleanup_system.rs
index 4d01f53c0..addcffae3 100644
--- a/maplibre/src/render/systems/cleanup_system.rs
+++ b/maplibre/src/render/systems/cleanup_system.rs
@@ -1,16 +1,29 @@
 use crate::{
     context::MapContext,
-    render::render_phase::{LayerItem, RenderPhase, TileMaskItem},
+    render::render_phase::{LayerItem, RenderPhase, TileMaskItem, TranslucentItem},
+    tcs::system::{SystemError, SystemResult},
 };
 
-pub fn cleanup_system(MapContext { world, .. }: &mut MapContext) {
-    let Some((layer_item_phase, tile_mask_phase)) = world
-        .resources
-        .query_mut::<(&mut RenderPhase<LayerItem>, &mut RenderPhase<TileMaskItem>)>()
+pub fn cleanup_system(
+    MapContext {
+        world, view_state, ..
+    }: &mut MapContext,
+) -> SystemResult {
+    let Some((layer_item_phase, tile_mask_phase, translucent_phase)) =
+        world.resources.query_mut::<(
+            &mut RenderPhase<LayerItem>,
+            &mut RenderPhase<TileMaskItem>,
+            &mut RenderPhase<TranslucentItem>,
+        )>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     layer_item_phase.clear();
     tile_mask_phase.clear();
+    translucent_phase.clear();
+
+    view_state.update_references();
+
+    Ok(())
 }
diff --git a/maplibre/src/render/systems/graph_runner_system.rs b/maplibre/src/render/systems/graph_runner_system.rs
index 15994991e..09cae68bf 100644
--- a/maplibre/src/render/systems/graph_runner_system.rs
+++ b/maplibre/src/render/systems/graph_runner_system.rs
@@ -7,7 +7,7 @@ use log::error;
 use crate::{
     context::MapContext,
     render::{eventually::Eventually::Initialized, graph_runner::RenderGraphRunner, Renderer},
-    tcs::system::System,
+    tcs::system::{System, SystemError, SystemResult},
 };
 
 /// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.
@@ -33,7 +33,7 @@ impl System for GraphRunnerSystem {
                 },
             ..
         }: &mut MapContext,
-    ) {
+    ) -> SystemResult {
         render_graph.update(state);
 
         if let Err(e) = RenderGraphRunner::run(render_graph, device, queue, state, world) {
@@ -57,18 +57,22 @@ impl System for GraphRunnerSystem {
         {
             let _span = tracing::info_span!("present_frames").entered();
 
-            if let Initialized(render_target) = state.render_target.take() {
-                if let Some(surface_texture) = render_target.take_surface_texture() {
-                    surface_texture.present();
-                }
+            let Initialized(render_target) = state.render_target.take() else {
+                return Err(SystemError::Dependencies);
+            };
 
-                #[cfg(feature = "tracing-tracy")]
-                tracing::event!(
-                    tracing::Level::INFO,
-                    message = "finished frame",
-                    tracy.frame_mark = true
-                );
+            if let Some(surface_texture) = render_target.take_surface_texture() {
+                surface_texture.present();
             }
+
+            #[cfg(feature = "tracing-tracy")]
+            tracing::event!(
+                tracing::Level::INFO,
+                message = "finished frame",
+                tracy.frame_mark = true
+            );
+
+            Ok(())
         }
     }
 }
diff --git a/maplibre/src/render/systems/resource_system.rs b/maplibre/src/render/systems/resource_system.rs
index 11bdee63b..a77f67ecf 100644
--- a/maplibre/src/render/systems/resource_system.rs
+++ b/maplibre/src/render/systems/resource_system.rs
@@ -13,7 +13,7 @@ use crate::{
         tile_view_pattern::{TileViewPattern, WgpuTileViewPattern, DEFAULT_TILE_VIEW_PATTERN_SIZE},
         MaskPipeline, Renderer,
     },
-    tcs::system::System,
+    tcs::system::{System, SystemError, SystemResult},
 };
 
 #[derive(Default)]
@@ -37,12 +37,12 @@ impl System for ResourceSystem {
             world,
             ..
         }: &mut MapContext,
-    ) {
+    ) -> SystemResult {
         let Some((tile_view_pattern, mask_pipeline)) = world.resources.query_mut::<(
             &mut Eventually<WgpuTileViewPattern>,
             &mut Eventually<MaskPipeline>,
         )>() else {
-            return;
+            return Err(SystemError::Dependencies);
         };
 
         let surface = &mut state.surface;
@@ -128,10 +128,13 @@ impl System for ResourceSystem {
                 false,
                 surface.is_multisampling_supported(settings.msaa),
                 false,
+                false,
             )
             .describe_render_pipeline()
             .initialize(device);
             MaskPipeline(pipeline)
         });
+
+        Ok(())
     }
 }
diff --git a/maplibre/src/render/systems/sort_phase_system.rs b/maplibre/src/render/systems/sort_phase_system.rs
index 90af4e800..21198f7e8 100644
--- a/maplibre/src/render/systems/sort_phase_system.rs
+++ b/maplibre/src/render/systems/sort_phase_system.rs
@@ -1,14 +1,17 @@
 use crate::{
     context::MapContext,
     render::render_phase::{LayerItem, RenderPhase},
+    tcs::system::SystemResult,
 };
 
 /// This system sorts all [`RenderPhases`](RenderPhase) for the [`PhaseItem`] type.
-pub fn sort_phase_system(MapContext { world, .. }: &mut MapContext) {
+pub fn sort_phase_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
     // We are only sorting layers and not masks
     world
         .resources
         .get_mut::<RenderPhase<LayerItem>>()
         .unwrap()
         .sort();
+
+    Ok(())
 }
diff --git a/maplibre/src/render/systems/tile_view_pattern_system.rs b/maplibre/src/render/systems/tile_view_pattern_system.rs
index 0ad7f6193..c114d8b44 100644
--- a/maplibre/src/render/systems/tile_view_pattern_system.rs
+++ b/maplibre/src/render/systems/tile_view_pattern_system.rs
@@ -5,22 +5,28 @@ use crate::{
     render::{
         eventually::{Eventually, Eventually::Initialized},
         tile_view_pattern::{ViewTileSources, WgpuTileViewPattern, DEFAULT_TILE_SIZE},
+        view_state::ViewStatePadding,
     },
+    tcs::system::{SystemError, SystemResult},
 };
 
 pub fn tile_view_pattern_system(
     MapContext {
         view_state, world, ..
     }: &mut MapContext,
-) {
+) -> SystemResult {
     let Some((Initialized(tile_view_pattern), view_tile_sources)) = world
         .resources
         .query::<(&Eventually<WgpuTileViewPattern>, &ViewTileSources)>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
-    let view_region =
-        view_state.create_view_region(view_state.zoom().zoom_level(DEFAULT_TILE_SIZE));
+
+    // Create the tile view pattern only for tiles in view -> Tight
+    let view_region = view_state.create_view_region(
+        view_state.zoom().zoom_level(DEFAULT_TILE_SIZE),
+        ViewStatePadding::Tight,
+    );
 
     if let Some(view_region) = &view_region {
         let zoom = view_state.zoom();
@@ -33,11 +39,13 @@ pub fn tile_view_pattern_system(
             .resources
             .query_mut::<&mut Eventually<WgpuTileViewPattern>>()
         else {
-            return;
+            return Err(SystemError::Dependencies);
         };
 
         log::trace!("Tiles in view: {}", view_tiles.len());
 
         tile_view_pattern.update_pattern(view_tiles);
     }
+
+    Ok(())
 }
diff --git a/maplibre/src/render/systems/upload_system.rs b/maplibre/src/render/systems/upload_system.rs
index 8ee54d9b7..ca5c2ae7b 100644
--- a/maplibre/src/render/systems/upload_system.rs
+++ b/maplibre/src/render/systems/upload_system.rs
@@ -6,6 +6,7 @@ use crate::{
         tile_view_pattern::WgpuTileViewPattern,
         Renderer,
     },
+    tcs::system::{SystemError, SystemResult},
 };
 
 pub fn upload_system(
@@ -15,14 +16,16 @@ pub fn upload_system(
         renderer: Renderer { queue, .. },
         ..
     }: &mut MapContext,
-) {
+) -> SystemResult {
     let Some(Initialized(tile_view_pattern)) = world
         .resources
         .query_mut::<&mut Eventually<WgpuTileViewPattern>>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     let view_proj = view_state.view_projection();
     tile_view_pattern.upload_pattern(queue, &view_proj);
+
+    Ok(())
 }
diff --git a/maplibre/src/render/translucent_pass.rs b/maplibre/src/render/translucent_pass.rs
new file mode 100644
index 000000000..5f5c7dcee
--- /dev/null
+++ b/maplibre/src/render/translucent_pass.rs
@@ -0,0 +1,109 @@
+use std::ops::Deref;
+
+use wgpu::StoreOp;
+
+use crate::{
+    render::{
+        draw_graph,
+        graph::{Node, NodeRunError, RenderContext, RenderGraphContext, SlotInfo},
+        render_phase::{RenderPhase, TranslucentItem},
+        resource::TrackedRenderPass,
+        Eventually::Initialized,
+        RenderResources,
+    },
+    tcs::world::World,
+};
+
+pub struct TranslucentPassNode {}
+
+impl TranslucentPassNode {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Node for TranslucentPassNode {
+    fn input(&self) -> Vec<SlotInfo> {
+        vec![]
+    }
+
+    fn update(&mut self, _state: &mut RenderResources) {}
+
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        state: &RenderResources,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let Initialized(render_target) = &state.render_target else {
+            return Ok(());
+        };
+        let Initialized(multisampling_texture) = &state.multisampling_texture else {
+            return Ok(());
+        };
+
+        let color_attachment = if let Some(texture) = multisampling_texture {
+            wgpu::RenderPassColorAttachment {
+                view: &texture.view,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: StoreOp::Store,
+                },
+                resolve_target: Some(render_target.deref()),
+            }
+        } else {
+            wgpu::RenderPassColorAttachment {
+                view: render_target.deref(),
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: StoreOp::Store,
+                },
+                resolve_target: None,
+            }
+        };
+
+        let render_pass =
+            render_context
+                .command_encoder
+                .begin_render_pass(&wgpu::RenderPassDescriptor {
+                    label: Some("translucent_pass"),
+                    color_attachments: &[Some(color_attachment)],
+                    depth_stencil_attachment: None,
+                    timestamp_writes: None,
+                    occlusion_query_set: None,
+                });
+
+        let mut tracked_pass = TrackedRenderPass::new(render_pass);
+
+        // TODO: Automatically raise error when items get linearly too many (+1k)
+
+        if let Some(mask_items) = world.resources.get::<RenderPhase<TranslucentItem>>() {
+            log::trace!(
+                "RenderPhase<TranslucentItem>::size() = {}",
+                mask_items.size()
+            );
+            for item in mask_items {
+                item.draw_function.draw(&mut tracked_pass, world, item);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub struct MainPassDriverNode;
+
+impl Node for MainPassDriverNode {
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        _render_context: &mut RenderContext,
+        _resources: &RenderResources,
+        _world: &World,
+    ) -> Result<(), NodeRunError> {
+        graph.run_sub_graph(draw_graph::NAME, vec![])?;
+
+        Ok(())
+    }
+}
diff --git a/maplibre/src/render/view_state.rs b/maplibre/src/render/view_state.rs
index 42fadeaea..b3ea7aad4 100644
--- a/maplibre/src/render/view_state.rs
+++ b/maplibre/src/render/view_state.rs
@@ -21,6 +21,14 @@ use crate::{
 const VIEW_REGION_PADDING: i32 = 1;
 const MAX_N_TILES: usize = 512;
 
+pub enum ViewStatePadding {
+    // This is helpful for loading a set of tiles.
+    Loose,
+    // This is helpful for rendering a set of tiles.
+    Tight,
+}
+
+#[derive(Clone)] // TODO: Remove
 pub struct ViewState {
     zoom: ChangeObserver<Zoom>,
     camera: ChangeObserver<Camera>,
@@ -70,12 +78,19 @@ impl ViewState {
         self.height = size.height() as f64;
     }
 
-    pub fn create_view_region(&self, visible_level: ZoomLevel) -> Option<ViewRegion> {
+    pub fn create_view_region(
+        &self,
+        visible_level: ZoomLevel,
+        padding: ViewStatePadding,
+    ) -> Option<ViewRegion> {
         self.view_region_bounding_box(&self.view_projection().invert())
             .map(|bounding_box| {
                 ViewRegion::new(
                     bounding_box,
-                    VIEW_REGION_PADDING,
+                    match padding {
+                        ViewStatePadding::Loose => VIEW_REGION_PADDING,
+                        ViewStatePadding::Tight => 0,
+                    },
                     MAX_N_TILES,
                     *self.zoom,
                     visible_level,
@@ -83,7 +98,7 @@ impl ViewState {
             })
     }
 
-    pub fn get_intersection_time(
+    fn get_intersection_time(
         ray_origin: Vector3<f64>,
         ray_direction: Vector3<f64>,
         plane_origin: Vector3<f64>,
@@ -105,7 +120,7 @@ impl ViewState {
         // is in the plane, to within rounding error.
     }
 
-    pub fn furthest_distance(&self, camera_height: f64, center_offset: Point2<f64>) -> f64 {
+    fn furthest_distance(&self, camera_height: f64, center_offset: Point2<f64>) -> f64 {
         let perspective = &self.perspective;
         let width = self.width;
         let height = self.height;
@@ -143,7 +158,7 @@ impl ViewState {
         let half_fovy = fovy / 2.0;
 
         // Camera height, such that given a certain field-of-view, exactly height/2 are visible on ground.
-        let camera_to_center_distance = (height / 2.0) / (half_fovy.tan()); // TODO: Not sure why it is height here and not width
+        let camera_to_center_distance = (height / 2.0) / (half_fovy.tan()); // We are using `height` here because this is the FOV in y direction (fovy).
         camera_to_center_distance
     }
 
@@ -173,14 +188,14 @@ impl ViewState {
         // when rendering it's layers using custom layers. This value was experimentally chosen and
         // seems to solve z-fighting issues in deckgl while not clipping buildings too close to the camera.
         //
-        // TODO remove: In tile.vertex.wgsl we are setting each layer's final `z` in ndc space to `z_index`.
+        // TODO remove: In fill.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
         let near_z = height / 50.0;
 
-        let mut perspective =
+        let perspective =
             self.perspective
                 .calc_matrix_with_center(width, height, near_z, far_z, center_offset);
 
@@ -235,7 +250,7 @@ impl ViewState {
 
     /// A transform which can be used to transform between clip and window space.
     /// Adopted from [here](https://docs.microsoft.com/en-us/windows/win32/direct3d9/viewports-and-clipping#viewport-rectangle) (Direct3D).
-    fn clip_to_window_transform(&self) -> Matrix4<f64> {
+    pub(crate) fn clip_to_window_transform(&self) -> Matrix4<f64> {
         let min_depth = 0.0;
         let max_depth = 1.0;
         let x = 0.0;
@@ -255,7 +270,7 @@ impl ViewState {
     /// Transforms coordinates in clip space to window coordinates.
     ///
     /// Adopted from [here](https://docs.microsoft.com/en-us/windows/win32/dxtecharts/the-direct3d-transformation-pipeline) (Direct3D).
-    fn clip_to_window(&self, clip: &Vector4<f64>) -> Vector4<f64> {
+    pub(crate) fn clip_to_window(&self, clip: &Vector4<f64>) -> Vector4<f64> {
         #[rustfmt::skip]
         let ndc = Vector4::new(
             clip.x / clip.w,
@@ -266,6 +281,18 @@ impl ViewState {
 
         self.clip_to_window_transform() * ndc
     }
+
+    /// The way how maplibre converts from clip to window space: https://github.com/maplibre/maplibre-native/blob/4add9ead08799577a37c465b8cb1266676b6c41e/src/mbgl/text/collision_index.cpp/#L437-L438
+    pub(crate) fn clip_to_window_maplibre(&self, clip: &Vector4<f64>) -> Vector4<f64> {
+        assert_eq!(clip.z, 0.0);
+        return Vector4::new(
+            ((clip.x / clip.w + 1.) / 2.) * self.width,
+            ((-clip.y / clip.w + 1.) / 2.) * self.height,
+            0.0,
+            1.0,
+        );
+    }
+
     /// Alternative implementation to `clip_to_window`. Transforms coordinates in clip space to
     /// window coordinates.
     ///
@@ -403,7 +430,7 @@ impl ViewState {
 
         Some(Aabb2::new(Point2::from(min), Point2::from(max)))
     }
-    /// An alternative implementation for `view_bounding_box`.
+    /// An alternative implementation for `view_region_bounding_box`.
     ///
     /// This implementation works in the NDC space. We are creating a plane in the world 3D space.
     /// Then we are transforming it to the NDC space. In NDC space it is easy to calculate
@@ -460,6 +487,12 @@ impl ViewState {
             Point2::new(max_x, max_y),
         ))
     }
+    pub fn height(&self) -> f64 {
+        self.height
+    }
+    pub fn width(&self) -> f64 {
+        self.width
+    }
 }
 
 #[cfg(test)]
diff --git a/maplibre/src/schedule.rs b/maplibre/src/schedule.rs
index 0e283f1e0..2fb77b3a3 100644
--- a/maplibre/src/schedule.rs
+++ b/maplibre/src/schedule.rs
@@ -1,17 +1,20 @@
 use std::collections::HashMap;
 
 use downcast_rs::{impl_downcast, Downcast};
+use thiserror::Error;
 
 use crate::{
     context::MapContext,
     define_label,
-    tcs::system::{stage::SystemStage, IntoSystemContainer},
+    tcs::system::{stage::SystemStage, IntoSystemContainer, SystemError},
 };
 
 pub struct NopStage;
 
 impl Stage for NopStage {
-    fn run(&mut self, _context: &mut MapContext) {}
+    fn run(&mut self, _context: &mut MapContext) -> StageResult {
+        Ok(())
+    }
 }
 
 #[macro_export]
@@ -57,20 +60,30 @@ impl<const I: usize, S> Stage for MultiStage<I, S>
 where
     S: Stage,
 {
-    fn run(&mut self, context: &mut MapContext) {
+    fn run(&mut self, context: &mut MapContext) -> StageResult {
         for stage in self.stages.iter_mut() {
-            stage.run(context)
+            stage.run(context)?
         }
+
+        Ok(())
     }
 }
 
 define_label!(StageLabel);
 pub(crate) type BoxedStageLabel = Box<dyn StageLabel>;
 
+#[derive(Error, Debug)]
+pub enum StageError {
+    #[error("system errored")]
+    System(#[from] SystemError),
+}
+
+pub type StageResult = Result<(), StageError>;
+
 pub trait Stage: Downcast {
     /// Runs the stage; this happens once per update.
     /// Implementors must initialize all of their state before running the first time.
-    fn run(&mut self, context: &mut MapContext);
+    fn run(&mut self, context: &mut MapContext) -> StageResult;
 }
 
 impl_downcast!(Stage);
@@ -257,13 +270,14 @@ impl Schedule {
     }
 
     /// Executes each [`Stage`] contained in the schedule, one at a time.
-    pub fn run_once(&mut self, context: &mut MapContext) {
+    pub fn run_once(&mut self, context: &mut MapContext) -> StageResult {
         for label in &self.stage_order {
             #[cfg(feature = "trace")]
             let _stage_span = tracing::info_span!("stage", name = ?label).entered();
             let stage = self.stages.get_mut(label).unwrap(); // TODO: Remove unwrap
-            stage.run(context);
+            stage.run(context)?;
         }
+        Ok(())
     }
 
     pub fn clear(&mut self) {
@@ -286,10 +300,11 @@ impl Schedule {
     /// # use maplibre::context::MapContext;
     /// # use maplibre::tcs::system::stage::SystemStage;
     /// # use maplibre::schedule::{Schedule, NopStage};
+    /// # use maplibre::tcs::system::SystemError;
     /// #
     /// # let mut schedule = Schedule::default();
     /// # schedule.add_stage("my_stage", SystemStage::default());
-    /// # fn my_system(context: &mut MapContext) {}
+    /// # fn my_system(context: &mut MapContext) -> Result<(), SystemError> { Ok(()) }
     /// #
     /// schedule.add_system_to_stage("my_stage", my_system);
     /// ```
@@ -309,7 +324,8 @@ impl Schedule {
 }
 
 impl Stage for Schedule {
-    fn run(&mut self, context: &mut MapContext) {
-        self.run_once(context);
+    fn run(&mut self, context: &mut MapContext) -> StageResult {
+        self.run_once(context)?;
+        Ok(())
     }
 }
diff --git a/maplibre/src/sdf/collision_system.rs b/maplibre/src/sdf/collision_system.rs
new file mode 100644
index 000000000..8db285dfd
--- /dev/null
+++ b/maplibre/src/sdf/collision_system.rs
@@ -0,0 +1,233 @@
+use std::borrow::Cow;
+
+use cgmath::{Matrix3, Vector3};
+
+use crate::{
+    context::MapContext,
+    coords::{EXTENT, TILE_SIZE},
+    euclid::Point2D,
+    legacy::{
+        buckets::symbol_bucket::PlacedSymbol,
+        collision_feature::{CollisionBox, CollisionFeature},
+        collision_index::CollisionIndex,
+        geometry::feature_index::{IndexedSubfeature, RefIndexedSubfeature},
+        geometry_tile_data::GeometryCoordinates,
+        MapMode,
+    },
+    render::{
+        eventually::{Eventually, Eventually::Initialized},
+        shaders::SDFShaderFeatureMetadata,
+        tile_view_pattern::WgpuTileViewPattern,
+        Renderer,
+    },
+    sdf::{SymbolBufferPool, SymbolLayersDataComponent},
+    tcs::system::{System, SystemError, SystemResult},
+};
+
+pub struct CollisionSystem {}
+
+impl Default for CollisionSystem {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CollisionSystem {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl System for CollisionSystem {
+    fn name(&self) -> Cow<'static, str> {
+        "sdf_populate_world_system".into()
+    }
+
+    fn run(
+        &mut self,
+        MapContext {
+            world,
+            view_state,
+            renderer: Renderer { device, queue, .. },
+            ..
+        }: &mut MapContext,
+    ) -> SystemResult {
+        let Some((Initialized(tile_view_pattern), Initialized(symbol_buffer_pool))) =
+            world.resources.query_mut::<(
+                &mut Eventually<WgpuTileViewPattern>,
+                &mut Eventually<SymbolBufferPool>,
+            )>()
+        else {
+            return Err(SystemError::Dependencies);
+        };
+
+        if !view_state.did_camera_change() {
+            // TODO
+            // return Ok(());
+        }
+
+        let mut collision_index = CollisionIndex::new(view_state, MapMode::Continuous);
+
+        for view_tile in tile_view_pattern.iter() {
+            let coords = view_tile.coords();
+            if let Some(component) = world.tiles.query::<&SymbolLayersDataComponent>(coords) {
+                for layer in &component.layers {
+                    let mut feature_metadata = vec![
+                        SDFShaderFeatureMetadata::default();
+                        layer
+                            .features
+                            .last()
+                            .map(|feature| feature.indices.end)
+                            .unwrap_or_default()
+                    ];
+
+                    for feature in &layer.features {
+                        // calculate where tile is
+
+                        let transform = coords.transform_for_zoom(view_state.zoom());
+
+                        let pos_matrix = view_state
+                            .view_projection()
+                            .to_model_view_projection(transform);
+
+                        let zoom_factor = view_state.zoom().scale_to_tile(&coords);
+
+                        let font_scale = 6.0;
+                        let scaling = Matrix3::from_cols(
+                            Vector3::new(zoom_factor * font_scale, 0.0, 0.0),
+                            Vector3::new(0.0, zoom_factor * font_scale, 0.0),
+                            Vector3::new(0.0, 0.0, 1.0),
+                        );
+
+                        let vec3 = Vector3::new(
+                            feature.bbox.max.x as f64,
+                            feature.bbox.max.y as f64,
+                            0.0f64,
+                        );
+                        let text_anchor = Vector3::new(
+                            feature.text_anchor.x as f64,
+                            feature.text_anchor.y as f64,
+                            0.0f64,
+                        );
+
+                        let shader = pos_matrix.get()
+                            * (scaling * (vec3 - text_anchor) + text_anchor).extend(1.0);
+                        let window = view_state.clip_to_window(&shader);
+
+                        //println!("{:?}", window);
+
+                        let anchor_point =
+                            Point2D::new(feature.bbox.min.x as f64, feature.bbox.min.y as f64); // TODO
+
+                        let boxes = vec![CollisionBox {
+                            anchor: anchor_point,
+                            x1: 0.0 * (EXTENT / TILE_SIZE),
+                            y1: 0. * (EXTENT / TILE_SIZE),
+                            x2: (feature.bbox.max.x - feature.bbox.min.x) as f64, //* (EXTENT / TILE_SIZE),
+                            y2: (feature.bbox.max.y - feature.bbox.min.y) as f64, // * (EXTENT / TILE_SIZE),
+                            signed_distance_from_anchor: 0.0,
+                        }]; // TODO
+
+                        let mut projected_boxes = vec![];
+                        let collision_feature = CollisionFeature {
+                            boxes,
+                            indexed_feature: IndexedSubfeature {
+                                ref_: RefIndexedSubfeature {
+                                    index: 0,
+                                    sort_index: 0,
+                                    source_layer_name: "".to_string(),
+                                    bucket_leader_id: "".to_string(),
+                                    bucket_instance_id: 0,
+                                    collision_group_id: 0,
+                                },
+                                source_layer_name_copy: "".to_string(),
+                                bucket_leader_idcopy: "".to_string(),
+                            },
+                            along_line: false, // false if point, else true
+                        };
+                        let (placed_text, is_offscreen) = collision_index.place_feature(
+                            &collision_feature,
+                            Point2D::zero(), // shift
+                            &pos_matrix,
+                            &pos_matrix.get(), // TODO
+                            //TILE_SIZE / EXTENT,
+                            1.0,
+                            &PlacedSymbol {
+                                anchor_point,
+                                segment: 0,
+                                lower_size: 0.0,
+                                upper_size: 0.0,
+                                line_offset: [0., 0.],
+                                writing_modes: Default::default(),
+                                line: GeometryCoordinates(vec![anchor_point.cast()]), // TODO can be linestring or just a single point
+                                tile_distances: vec![],                               // TODO
+                                glyph_offsets: vec![0., 0.],                          // TODO
+                                hidden: false,
+                                vertex_start_index: 0,
+                                cross_tile_id: 0,
+                                placed_orientation: None,
+                                angle: 0.0,
+
+                                placed_icon_index: None,
+                            },
+                            view_state.zoom().scale_to_zoom_level(coords.z),
+                            6.0,
+                            false,
+                            false,
+                            false,
+                            None,                               // avoidEdges
+                            Some(|f: &IndexedSubfeature| true), // collisionGroupPredicate
+                            &mut projected_boxes,               // output
+                        );
+                        if feature.str.starts_with("Ette") {
+                            //println!("{}", feature.str);
+                            //println!("{:?}", &collision_feature.boxes);
+                            //println!("proj {:?}", &projected_boxes.get(0));
+                        }
+
+                        if placed_text {
+                            collision_index.insert_feature(
+                                collision_feature,
+                                &projected_boxes,
+                                false,
+                                55,
+                                66,
+                            );
+
+                            for index in feature.indices.clone() {
+                                let index = layer.buffer.buffer.indices[index] as usize;
+                                feature_metadata[index].opacity = 1.0;
+                            }
+                        } else {
+                            for index in feature.indices.clone() {
+                                let index = layer.buffer.buffer.indices[index] as usize;
+                                feature_metadata[index].opacity = 0.0;
+                            }
+
+                            //feature_metadata.extend(iter::repeat(SDFShaderFeatureMetadata { opacity: 0.0 }).take(feature.indices.len()))
+                        }
+                    }
+
+                    if let Some(layer_at_coords) = symbol_buffer_pool.index().get_layers(coords) {
+                        for entry in layer_at_coords {
+                            debug_assert_eq!(entry.coords, coords);
+
+                            let source_layer = entry.style_layer.source_layer.as_ref().unwrap();
+
+                            if source_layer != &layer.source_layer {
+                                continue;
+                            }
+
+                            symbol_buffer_pool.update_feature_metadata(
+                                queue,
+                                entry,
+                                &feature_metadata,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/maplibre/src/sdf/mod.rs b/maplibre/src/sdf/mod.rs
new file mode 100644
index 000000000..0a75ffebe
--- /dev/null
+++ b/maplibre/src/sdf/mod.rs
@@ -0,0 +1,240 @@
+use std::{
+    marker::PhantomData,
+    ops::{Deref, Range},
+    rc::Rc,
+};
+
+use crate::{
+    coords::WorldTileCoords,
+    environment::Environment,
+    euclid::{Box2D, Point2D},
+    kernel::Kernel,
+    legacy::TileSpace,
+    plugin::Plugin,
+    render::{
+        eventually::Eventually,
+        graph::RenderGraph,
+        shaders::{
+            SDFShaderFeatureMetadata, ShaderLayerMetadata, ShaderSymbolVertex,
+            ShaderSymbolVertexNew,
+        },
+        RenderStageLabel,
+    },
+    schedule::Schedule,
+    sdf::resource::GlyphTexture,
+    tcs::{system::SystemContainer, tiles::TileComponent, world::World},
+    vector::{
+        resource::BufferPool,
+        tessellation::{IndexDataType, OverAlignedVertexBuffer},
+        VectorTransferables,
+    },
+};
+
+pub mod collision_system;
+mod populate_world_system;
+mod queue_system;
+mod render_commands;
+mod resource;
+mod resource_system;
+mod upload_system;
+
+pub mod tessellation;
+pub mod tessellation_new;
+pub mod text;
+
+struct SymbolPipeline(wgpu::RenderPipeline);
+
+impl Deref for SymbolPipeline {
+    type Target = wgpu::RenderPipeline;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+pub type SymbolBufferPool = BufferPool<
+    wgpu::Queue,
+    wgpu::Buffer,
+    ShaderSymbolVertexNew,
+    IndexDataType,
+    ShaderLayerMetadata,
+    SDFShaderFeatureMetadata,
+>;
+
+pub struct SdfPlugin<T>(PhantomData<T>);
+
+impl<T: VectorTransferables> Default for SdfPlugin<T> {
+    fn default() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl<E: Environment, T: VectorTransferables> Plugin<E> for SdfPlugin<T> {
+    fn build(
+        &self,
+        schedule: &mut Schedule,
+        kernel: Rc<Kernel<E>>,
+        world: &mut World,
+        _graph: &mut RenderGraph,
+    ) {
+        let resources = &mut world.resources;
+
+        resources.insert(Eventually::<SymbolPipeline>::Uninitialized);
+        resources.insert(Eventually::<SymbolBufferPool>::Uninitialized);
+        resources.insert(Eventually::<GlyphTexture>::Uninitialized);
+        resources.insert(Eventually::<(wgpu::Texture, wgpu::Sampler)>::Uninitialized);
+
+        schedule.add_system_to_stage(
+            RenderStageLabel::Extract,
+            SystemContainer::new(populate_world_system::PopulateWorldSystem::<E, T>::new(
+                &kernel,
+            )),
+        );
+
+        schedule.add_system_to_stage(RenderStageLabel::Prepare, resource_system::resource_system);
+        schedule.add_system_to_stage(RenderStageLabel::Queue, upload_system::upload_system); // FIXME tcs: Upload updates the TileView in tileviewpattern -> upload most run before prepare
+        schedule.add_system_to_stage(RenderStageLabel::Queue, queue_system::queue_system);
+
+        schedule.add_system_to_stage(
+            RenderStageLabel::PhaseSort,
+            SystemContainer::new(collision_system::CollisionSystem::new()),
+        );
+    }
+}
+
+pub struct Feature {
+    pub bbox: Box2D<f32, TileSpace>,
+    pub indices: Range<usize>,
+    pub text_anchor: Point2D<f32, TileSpace>,
+    pub str: String,
+}
+
+pub struct SymbolLayerData {
+    pub coords: WorldTileCoords,
+    pub source_layer: String,
+    pub buffer: OverAlignedVertexBuffer<ShaderSymbolVertex, IndexDataType>,
+    pub new_buffer: OverAlignedVertexBuffer<ShaderSymbolVertexNew, IndexDataType>, // TODO
+    pub features: Vec<Feature>,
+}
+
+#[derive(Default)]
+pub struct SymbolLayersDataComponent {
+    pub layers: Vec<SymbolLayerData>,
+}
+
+impl TileComponent for SymbolLayersDataComponent {}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use crate::{
+        euclid::{Point2D, Rect, Size2D},
+        legacy::{
+            bidi::Char16,
+            font_stack::FontStackHasher,
+            geometry_tile_data::{GeometryCoordinates, SymbolGeometryTileLayer},
+            glyph::{Glyph, GlyphDependencies, GlyphMap, GlyphMetrics, Glyphs},
+            glyph_atlas::{GlyphPosition, GlyphPositionMap, GlyphPositions},
+            image::ImageMap,
+            image_atlas::ImagePositions,
+            layout::{
+                layout::{BucketParameters, LayerTypeInfo, LayoutParameters},
+                symbol_feature::{SymbolGeometryTileFeature, VectorGeometryTileFeature},
+                symbol_layout::{FeatureIndex, LayerProperties, SymbolLayer, SymbolLayout},
+            },
+            style_types::SymbolLayoutProperties_Unevaluated,
+            CanonicalTileID, MapMode, OverscaledTileID,
+        },
+    };
+
+    #[test]
+    fn test() {
+        let fontStack = vec![
+            "Open Sans Regular".to_string(),
+            "Arial Unicode MS Regular".to_string(),
+        ];
+
+        let mut glyphDependencies = GlyphDependencies::new();
+
+        let tile_id = OverscaledTileID {
+            canonical: CanonicalTileID { x: 0, y: 0, z: 0 },
+            overscaled_z: 0,
+        };
+        let mut parameters = BucketParameters {
+            tile_id: tile_id,
+            mode: MapMode::Continuous,
+            pixel_ratio: 1.0,
+            layer_type: LayerTypeInfo,
+        };
+        let mut layout = SymbolLayout::new(
+            &parameters,
+            &vec![LayerProperties {
+                id: "layer".to_string(),
+                layer: SymbolLayer {
+                    layout: SymbolLayoutProperties_Unevaluated,
+                },
+            }],
+            Box::new(SymbolGeometryTileLayer {
+                name: "layer".to_string(),
+                features: vec![SymbolGeometryTileFeature::new(Box::new(
+                    VectorGeometryTileFeature {
+                        geometry: vec![GeometryCoordinates(vec![Point2D::new(1024, 1024)])],
+                    },
+                ))],
+            }),
+            &mut LayoutParameters {
+                bucket_parameters: &mut parameters.clone(),
+                glyph_dependencies: &mut glyphDependencies,
+                image_dependencies: &mut Default::default(),
+                available_images: &mut Default::default(),
+            },
+        )
+        .unwrap();
+
+        assert_eq!(glyphDependencies.len(), 1);
+
+        // Now we prepare the data, when we have the glyphs available
+
+        let image_positions = ImagePositions::new();
+
+        let mut glyphPosition = GlyphPosition {
+            rect: Rect::new(Point2D::new(0, 0), Size2D::new(10, 10)),
+            metrics: GlyphMetrics {
+                width: 18,
+                height: 18,
+                left: 2,
+                top: -8,
+                advance: 21,
+            },
+        };
+        let glyphPositions: GlyphPositions = GlyphPositions::from([(
+            FontStackHasher::new(&fontStack),
+            GlyphPositionMap::from([('中' as Char16, glyphPosition)]),
+        )]);
+
+        let mut glyph = Glyph::default();
+        glyph.id = '中' as Char16;
+        glyph.metrics = glyphPosition.metrics;
+
+        let glyphs: GlyphMap = GlyphMap::from([(
+            FontStackHasher::new(&fontStack),
+            Glyphs::from([('中' as Char16, Some(glyph))]),
+        )]);
+
+        let empty_image_map = ImageMap::new();
+        layout.prepare_symbols(&glyphs, &glyphPositions, &empty_image_map, &image_positions);
+
+        let mut output = HashMap::new();
+        layout.create_bucket(
+            image_positions,
+            Box::new(FeatureIndex),
+            &mut output,
+            false,
+            false,
+            &tile_id.canonical,
+        );
+
+        println!("{:#?}", output)
+    }
+}
diff --git a/maplibre/src/sdf/populate_world_system.rs b/maplibre/src/sdf/populate_world_system.rs
new file mode 100644
index 000000000..d5ab89b9b
--- /dev/null
+++ b/maplibre/src/sdf/populate_world_system.rs
@@ -0,0 +1,54 @@
+use std::{borrow::Cow, marker::PhantomData, rc::Rc};
+
+use crate::{
+    context::MapContext,
+    environment::Environment,
+    io::apc::{AsyncProcedureCall, Message},
+    kernel::Kernel,
+    sdf::SymbolLayersDataComponent,
+    tcs::system::{System, SystemResult},
+    vector::transferables::*,
+};
+
+pub struct PopulateWorldSystem<E: Environment, T> {
+    kernel: Rc<Kernel<E>>,
+    phantom_t: PhantomData<T>,
+}
+
+impl<E: Environment, T> PopulateWorldSystem<E, T> {
+    pub fn new(kernel: &Rc<Kernel<E>>) -> Self {
+        Self {
+            kernel: kernel.clone(),
+            phantom_t: Default::default(),
+        }
+    }
+}
+
+impl<E: Environment, T: VectorTransferables> System for PopulateWorldSystem<E, T> {
+    fn name(&self) -> Cow<'static, str> {
+        "sdf_populate_world_system".into()
+    }
+
+    fn run(&mut self, MapContext { world, .. }: &mut MapContext) -> SystemResult {
+        for message in self.kernel.apc().receive(|message| {
+            message.has_tag(T::SymbolLayerTessellated::message_tag())
+                || message.has_tag(T::LayerIndexed::message_tag())
+        }) {
+            let message: Message = message;
+            if message.has_tag(T::SymbolLayerTessellated::message_tag()) {
+                let message = message.into_transferable::<T::SymbolLayerTessellated>();
+
+                let Some(component) = world
+                    .tiles
+                    .query_mut::<&mut SymbolLayersDataComponent>(message.coords())
+                else {
+                    continue;
+                };
+
+                component.layers.push(message.to_bucket());
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/maplibre/src/sdf/queue_system.rs b/maplibre/src/sdf/queue_system.rs
new file mode 100644
index 000000000..59ca02ed2
--- /dev/null
+++ b/maplibre/src/sdf/queue_system.rs
@@ -0,0 +1,53 @@
+//! Queues [PhaseItems](crate::render::render_phase::PhaseItem) for rendering.
+
+use crate::{
+    context::MapContext,
+    render::{
+        eventually::{Eventually, Eventually::Initialized},
+        render_phase::{DrawState, RenderPhase, TranslucentItem},
+        tile_view_pattern::WgpuTileViewPattern,
+    },
+    sdf::{render_commands::DrawSymbols, SymbolBufferPool},
+    tcs::{
+        system::{SystemError, SystemResult},
+        tiles::Tile,
+    },
+};
+
+pub fn queue_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
+    let Some((Initialized(tile_view_pattern), translucent_phase, Initialized(symbol_buffer_pool))) =
+        world.resources.query_mut::<(
+            &mut Eventually<WgpuTileViewPattern>,
+            &mut RenderPhase<TranslucentItem>,
+            &mut Eventually<SymbolBufferPool>,
+        )>()
+    else {
+        return Err(SystemError::Dependencies);
+    };
+
+    for view_tile in tile_view_pattern.iter() {
+        let coords = &view_tile.coords();
+        tracing::trace!("Drawing tile at {coords}");
+
+        // draw tile normal or the source e.g. parent or children
+        view_tile.render(|source_shape| {
+            if let Some(layer_entries) =
+                symbol_buffer_pool.index().get_layers(source_shape.coords())
+            {
+                for layer_entry in layer_entries {
+                    // Draw tile
+                    translucent_phase.add(TranslucentItem {
+                        draw_function: Box::new(DrawState::<TranslucentItem, DrawSymbols>::new()),
+                        index: layer_entry.style_layer.index,
+                        style_layer: layer_entry.style_layer.id.clone(),
+                        tile: Tile {
+                            coords: layer_entry.coords,
+                        },
+                        source_shape: source_shape.clone(),
+                    });
+                }
+            };
+        });
+    }
+    Ok(())
+}
diff --git a/maplibre/src/sdf/render_commands.rs b/maplibre/src/sdf/render_commands.rs
new file mode 100644
index 000000000..9ff08c8a8
--- /dev/null
+++ b/maplibre/src/sdf/render_commands.rs
@@ -0,0 +1,117 @@
+use crate::{
+    render::{
+        eventually::{Eventually, Eventually::Initialized},
+        render_phase::{PhaseItem, RenderCommand, RenderCommandResult, TranslucentItem},
+        resource::TrackedRenderPass,
+        tile_view_pattern::WgpuTileViewPattern,
+        INDEX_FORMAT,
+    },
+    sdf::{resource::GlyphTexture, SymbolBufferPool, SymbolPipeline},
+    tcs::world::World,
+};
+
+pub struct SetSymbolPipeline;
+impl<P: PhaseItem> RenderCommand<P> for SetSymbolPipeline {
+    fn render<'w>(
+        world: &'w World,
+        _item: &P,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let Some((Initialized(GlyphTexture { ref bind_group, .. }), Initialized(symbol_pipeline))) =
+            world
+                .resources
+                .query::<(&Eventually<GlyphTexture>, &Eventually<SymbolPipeline>)>()
+        else {
+            return RenderCommandResult::Failure;
+        };
+
+        pass.set_bind_group(0, bind_group, &[]);
+        pass.set_render_pipeline(symbol_pipeline);
+        RenderCommandResult::Success
+    }
+}
+
+pub struct DrawSymbol;
+impl RenderCommand<TranslucentItem> for DrawSymbol {
+    fn render<'w>(
+        world: &'w World,
+        item: &TranslucentItem,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let Some((Initialized(symbol_buffer_pool), Initialized(tile_view_pattern))) =
+            world.resources.query::<(
+                &Eventually<SymbolBufferPool>,
+                &Eventually<WgpuTileViewPattern>,
+            )>()
+        else {
+            return RenderCommandResult::Failure;
+        };
+
+        let Some(vector_layers) = symbol_buffer_pool.index().get_layers(item.tile.coords) else {
+            return RenderCommandResult::Failure;
+        };
+
+        let Some(entry) = vector_layers
+            .iter()
+            .find(|entry| entry.style_layer.id == item.style_layer)
+        else {
+            return RenderCommandResult::Failure;
+        };
+
+        let source_shape = &item.source_shape;
+
+        let tile_view_pattern_buffer = source_shape
+            .buffer_range()
+            .expect("tile_view_pattern needs to be uploaded first"); // FIXME tcs
+
+        // Uses stencil value of requested tile and the shape of the requested tile
+        let reference = source_shape.coords().stencil_reference_value_3d() as u32;
+
+        tracing::trace!(
+            "Drawing layer {:?} at {}",
+            entry.style_layer.source_layer,
+            entry.coords
+        );
+
+        let index_range = entry.indices_buffer_range();
+
+        if index_range.is_empty() {
+            tracing::error!("Tried to draw a vector tile without any vertices");
+            return RenderCommandResult::Failure;
+        }
+
+        pass.set_stencil_reference(reference);
+
+        pass.set_index_buffer(
+            symbol_buffer_pool.indices().slice(index_range),
+            INDEX_FORMAT,
+        );
+        pass.set_vertex_buffer(
+            0,
+            symbol_buffer_pool
+                .vertices()
+                .slice(entry.vertices_buffer_range()),
+        );
+        pass.set_vertex_buffer(
+            1,
+            tile_view_pattern.buffer().slice(tile_view_pattern_buffer),
+        );
+        //pass.set_vertex_buffer(
+        //    2,
+        //    symbol_buffer_pool
+        //        .metadata()
+        //        .slice(entry.layer_metadata_buffer_range()),
+        //);
+        //pass.set_vertex_buffer(
+        //    3,
+        //    symbol_buffer_pool
+        //        .feature_metadata()
+        //        .slice(entry.feature_metadata_buffer_range()),
+        //);
+
+        pass.draw_indexed(entry.indices_range(), 0, 0..1);
+        RenderCommandResult::Success
+    }
+}
+
+pub type DrawSymbols = (SetSymbolPipeline, DrawSymbol);
diff --git a/maplibre/src/sdf/resource/glyph_texture.rs b/maplibre/src/sdf/resource/glyph_texture.rs
new file mode 100644
index 000000000..35d2cebde
--- /dev/null
+++ b/maplibre/src/sdf/resource/glyph_texture.rs
@@ -0,0 +1,39 @@
+pub struct GlyphTexture {
+    pub bind_group: wgpu::BindGroup,
+}
+
+impl GlyphTexture {
+    pub fn from_device(
+        device: &wgpu::Device,
+        texture: &wgpu::Texture,
+        sampler: &wgpu::Sampler,
+        layout: &wgpu::BindGroupLayout,
+    ) -> Self {
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&texture.create_view(
+                        &wgpu::TextureViewDescriptor {
+                            label: Some("Glyph texture view"),
+                            format: Some(wgpu::TextureFormat::R8Unorm),
+                            dimension: Some(wgpu::TextureViewDimension::D2),
+                            aspect: wgpu::TextureAspect::All,
+                            base_mip_level: 0,
+                            mip_level_count: None,
+                            base_array_layer: 0,
+                            array_layer_count: None,
+                        },
+                    )),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(sampler),
+                },
+            ],
+            label: Some("Glyph texture bind group"),
+        });
+        Self { bind_group }
+    }
+}
diff --git a/maplibre/src/sdf/resource/mod.rs b/maplibre/src/sdf/resource/mod.rs
new file mode 100644
index 000000000..9aee747dd
--- /dev/null
+++ b/maplibre/src/sdf/resource/mod.rs
@@ -0,0 +1,2 @@
+pub use glyph_texture::*;
+mod glyph_texture;
diff --git a/maplibre/src/sdf/resource_system.rs b/maplibre/src/sdf/resource_system.rs
new file mode 100644
index 000000000..279f285d7
--- /dev/null
+++ b/maplibre/src/sdf/resource_system.rs
@@ -0,0 +1,113 @@
+//! Prepares GPU-owned resources by initializing them if they are uninitialized or out-of-date.
+use wgpu::util::{DeviceExt, TextureDataOrder};
+
+use crate::{
+    context::MapContext,
+    render::{
+        eventually::Eventually,
+        resource::{RenderPipeline, TilePipeline},
+        shaders,
+        shaders::Shader,
+        RenderResources, Renderer,
+    },
+    sdf::{resource::GlyphTexture, text::GlyphSet, SymbolBufferPool, SymbolPipeline},
+    tcs::system::{SystemError, SystemResult},
+    vector::resource::BufferPool,
+};
+
+pub fn resource_system(
+    MapContext {
+        world,
+        renderer:
+            Renderer {
+                device,
+                queue,
+                resources: RenderResources { surface, .. },
+                settings,
+                ..
+            },
+        ..
+    }: &mut MapContext,
+) -> SystemResult {
+    let Some((
+        symbol_buffer_pool,
+        symbol_pipeline,
+        glyph_texture_sampler,
+        glyph_texture_bind_group,
+    )) = world.resources.query_mut::<(
+        &mut Eventually<SymbolBufferPool>,
+        &mut Eventually<SymbolPipeline>,
+        &mut Eventually<(wgpu::Texture, wgpu::Sampler)>,
+        &mut Eventually<GlyphTexture>,
+    )>()
+    else {
+        return Err(SystemError::Dependencies);
+    };
+
+    symbol_buffer_pool.initialize(|| BufferPool::from_device(device));
+
+    symbol_pipeline.initialize(|| {
+        let tile_shader = shaders::SymbolShader {
+            format: surface.surface_format(),
+        };
+
+        let pipeline = TilePipeline::new(
+            "symbol_pipeline".into(),
+            *settings,
+            tile_shader.describe_vertex(),
+            tile_shader.describe_fragment(),
+            false,
+            false,
+            true, // TODO ignore tile mask
+            false,
+            surface.is_multisampling_supported(settings.msaa),
+            false,
+            true,
+        )
+        .describe_render_pipeline()
+        .initialize(device);
+
+        let (texture, sampler) = glyph_texture_sampler.initialize(|| {
+            let data = include_bytes!("../../../data/0-255.pbf");
+            let glyphs = GlyphSet::try_from(data.as_slice()).unwrap();
+
+            let (width, height) = glyphs.get_texture_dimensions();
+
+            let texture = device.create_texture_with_data(
+                queue,
+                &wgpu::TextureDescriptor {
+                    label: Some("Glyph Texture"),
+                    size: wgpu::Extent3d {
+                        width: width as _,
+                        height: height as _,
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: wgpu::TextureFormat::R8Unorm,
+                    usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+                    view_formats: &[wgpu::TextureFormat::R8Unorm], // TODO
+                },
+                TextureDataOrder::LayerMajor, // TODO
+                glyphs.get_texture_bytes(),
+            );
+
+            let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+                // SDF rendering requires linear interpolation
+                mag_filter: wgpu::FilterMode::Linear,
+                min_filter: wgpu::FilterMode::Linear,
+                ..Default::default()
+            });
+
+            (texture, sampler)
+        });
+
+        glyph_texture_bind_group.initialize(|| {
+            GlyphTexture::from_device(device, texture, sampler, &pipeline.get_bind_group_layout(0))
+        });
+
+        SymbolPipeline(pipeline)
+    });
+    Ok(())
+}
diff --git a/maplibre/src/sdf/tessellation.rs b/maplibre/src/sdf/tessellation.rs
new file mode 100644
index 000000000..70402883b
--- /dev/null
+++ b/maplibre/src/sdf/tessellation.rs
@@ -0,0 +1,278 @@
+//! Tessellation for lines and polygons is implemented here.
+
+use csscolorparser::Color;
+use geozero::{ColumnValue, FeatureProcessor, GeomProcessor, PropertyProcessor};
+use lyon::{
+    geom::euclid::{Box2D, Point2D},
+    tessellation::{
+        geometry_builder::MaxIndex, BuffersBuilder, FillOptions, FillTessellator, VertexBuffers,
+    },
+};
+
+use crate::{
+    legacy::TileSpace,
+    render::shaders::ShaderSymbolVertex,
+    sdf::{
+        text::{Anchor, Glyph, GlyphSet, SymbolVertexBuilder},
+        Feature,
+    },
+};
+
+/// Vertex buffers index data type.
+pub type IndexDataType = u32; // Must match INDEX_FORMAT
+
+type GeoResult<T> = geozero::error::Result<T>;
+
+/// Build tessellations with vectors.
+pub struct TextTessellator<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> {
+    glyphs: GlyphSet,
+
+    // output
+    pub quad_buffer: VertexBuffers<ShaderSymbolVertex, I>,
+    pub features: Vec<Feature>,
+
+    // iteration variables
+    current_index: usize,
+    current_text: Option<String>,
+    current_origin: Option<Box2D<f32, TileSpace>>,
+}
+
+impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> Default
+    for TextTessellator<I>
+{
+    fn default() -> Self {
+        let data = include_bytes!("../../../data/0-255.pbf");
+        let glyphs = GlyphSet::try_from(data.as_slice()).unwrap();
+        Self {
+            glyphs,
+            quad_buffer: VertexBuffers::new(),
+            features: Vec::new(),
+            current_index: 0,
+            current_text: None,
+            current_origin: None,
+        }
+    }
+}
+
+enum StringGlyph<'a> {
+    Char(char),
+    Glyph(&'a Glyph),
+}
+
+impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> TextTessellator<I> {
+    pub fn tessellate_glyph_quads(
+        &mut self,
+        origin: [f32; 2],
+        label_text: &str,
+        color: Color,
+    ) -> Option<Box2D<f32, TileSpace>> {
+        let mut tessellator = FillTessellator::new();
+
+        let mut next_origin = origin;
+
+        let texture_dimensions = self.glyphs.get_texture_dimensions();
+        let texture_dimensions = (texture_dimensions.0 as f32, texture_dimensions.1 as f32);
+
+        // TODO: handle line wrapping / line height
+        let mut bbox = None;
+        for str_glyph in label_text
+            .chars()
+            .map(|c| {
+                self.glyphs
+                    .glyphs
+                    .get(&c)
+                    .map(StringGlyph::Glyph)
+                    .unwrap_or_else(|| StringGlyph::Char(c))
+            })
+            .collect::<Vec<_>>()
+        {
+            let glyph = match str_glyph {
+                StringGlyph::Glyph(glyph) => glyph,
+                StringGlyph::Char(c) => match c {
+                    ' ' => {
+                        next_origin[0] += 10.0; // Spaces are 10 units wide
+                        continue;
+                    }
+                    _ => {
+                        log::error!("unhandled char {}", c);
+                        continue;
+                    }
+                },
+            };
+
+            let glyph_dims = glyph.buffered_dimensions();
+            let width = glyph_dims.0 as f32;
+            let height = glyph_dims.1 as f32;
+
+            let glyph_anchor = [
+                next_origin[0] + glyph.left_bearing as f32,
+                next_origin[1] - glyph.top_bearing as f32,
+                0.,
+            ];
+
+            let glyph_bbox = Box2D::new(
+                (glyph_anchor[0], glyph_anchor[1]).into(),
+                (glyph_anchor[0] + width, glyph_anchor[1] + height).into(),
+            );
+
+            bbox = bbox.map_or_else(
+                || Some(glyph_bbox),
+                |bbox: Box2D<_, TileSpace>| Some(bbox.union(&glyph_bbox)),
+            );
+
+            tessellator
+                .tessellate_rectangle(
+                    &glyph_bbox.cast_unit(),
+                    &FillOptions::default(),
+                    &mut BuffersBuilder::new(
+                        &mut self.quad_buffer,
+                        SymbolVertexBuilder {
+                            glyph_anchor,
+                            text_anchor: [origin[0], origin[1], 0.0],
+                            texture_dimensions,
+                            sprite_dimensions: (width, height),
+                            sprite_offset: (
+                                glyph.origin_offset().0 as f32,
+                                glyph.origin_offset().1 as f32,
+                            ),
+                            color: color.to_rgba8(), // TODO: is this conversion oke?
+                            glyph: true,             // Set here to true to use SDF rendering
+                        },
+                    ),
+                )
+                .ok()?;
+
+            next_origin[0] += glyph.advance() as f32 + 1.0;
+        }
+
+        bbox
+    }
+}
+
+impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> GeomProcessor
+    for TextTessellator<I>
+{
+    fn xy(&mut self, x: f64, y: f64, _idx: usize) -> GeoResult<()> {
+        if self.current_origin.is_some() {
+            //FIXME
+            unreachable!("Text labels have only a single origin point")
+        } else {
+            self.current_origin = Some(Box2D::new(
+                Point2D::new(x as f32, y as f32),
+                Point2D::new(x as f32, y as f32),
+            ))
+        }
+
+        Ok(())
+    }
+
+    fn point_begin(&mut self, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn point_end(&mut self, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn multipoint_begin(&mut self, _size: usize, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn multipoint_end(&mut self, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn linestring_begin(&mut self, _tagged: bool, _size: usize, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn linestring_end(&mut self, _tagged: bool, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn multilinestring_begin(&mut self, _size: usize, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn multilinestring_end(&mut self, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn polygon_begin(&mut self, _tagged: bool, _size: usize, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn polygon_end(&mut self, _tagged: bool, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn multipolygon_begin(&mut self, _size: usize, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+
+    fn multipolygon_end(&mut self, _idx: usize) -> GeoResult<()> {
+        Ok(())
+    }
+}
+
+impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> PropertyProcessor
+    for TextTessellator<I>
+{
+    fn property(
+        &mut self,
+        _idx: usize,
+        name: &str,
+        value: &ColumnValue,
+    ) -> geozero::error::Result<bool> {
+        // TODO: Support different tags
+        if name == "name" {
+            match value {
+                ColumnValue::String(str) => {
+                    self.current_text = Some(str.to_string());
+                }
+                _ => {}
+            }
+        }
+        Ok(true)
+    }
+}
+
+impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> FeatureProcessor
+    for TextTessellator<I>
+{
+    fn feature_end(&mut self, _idx: u64) -> geozero::error::Result<()> {
+        if let (Some(origin), Some(text)) = (&self.current_origin, self.current_text.clone()) {
+            if text.is_empty() {
+                panic!("dud")
+            }
+            let anchor = Anchor::BottomLeft;
+            // TODO: add more anchor possibilities
+            let origin = match anchor {
+                Anchor::Center => origin.center(), // FIXME: origin is currently always a point
+                Anchor::BottomLeft => origin.min,
+                _ => unimplemented!("no support for this anchor"),
+            };
+            let bbox = self.tessellate_glyph_quads(
+                origin.to_array(),
+                text.as_str(),
+                Color::from_linear_rgba(1.0, 0., 0., 1.),
+            );
+
+            let next_index = self.quad_buffer.indices.len();
+            let start = self.current_index;
+            let end = next_index;
+            self.current_index = next_index;
+
+            self.features.push(Feature {
+                bbox: bbox.unwrap_or(Box2D::new(origin, origin)),
+                indices: start..end,
+                text_anchor: origin.cast(),
+                str: text,
+            });
+
+            self.current_origin = None;
+            self.current_text = None;
+        }
+        Ok(())
+    }
+}
diff --git a/maplibre/src/sdf/tessellation_new.rs b/maplibre/src/sdf/tessellation_new.rs
new file mode 100644
index 000000000..16409392f
--- /dev/null
+++ b/maplibre/src/sdf/tessellation_new.rs
@@ -0,0 +1,294 @@
+//! Tessellation for lines and polygons is implemented here.
+
+use std::collections::HashMap;
+
+use geo_types::Geometry;
+use geozero::{
+    geo_types::GeoWriter, ColumnValue, FeatureProcessor, GeomProcessor, PropertyProcessor,
+};
+use lyon::{
+    geom::euclid::{Box2D, Point2D},
+    tessellation::VertexBuffers,
+};
+
+use crate::{
+    euclid::{Rect, Size2D},
+    legacy::{
+        bidi::Char16,
+        buckets::symbol_bucket::SymbolBucketBuffer,
+        font_stack::FontStackHasher,
+        geometry_tile_data::{GeometryCoordinates, SymbolGeometryTileLayer},
+        glyph::{Glyph, GlyphDependencies, GlyphMap, GlyphMetrics, Glyphs},
+        glyph_atlas::{GlyphPosition, GlyphPositionMap, GlyphPositions},
+        image::ImageMap,
+        image_atlas::ImagePositions,
+        layout::{
+            layout::{BucketParameters, LayerTypeInfo, LayoutParameters},
+            symbol_feature::{SymbolGeometryTileFeature, VectorGeometryTileFeature},
+            symbol_layout::{FeatureIndex, LayerProperties, SymbolLayer, SymbolLayout},
+        },
+        style_types::SymbolLayoutProperties_Unevaluated,
+        tagged_string::SectionOptions,
+        CanonicalTileID, MapMode, OverscaledTileID, TileSpace,
+    },
+    render::shaders::ShaderSymbolVertexNew,
+    sdf::{tessellation::IndexDataType, text::GlyphSet, Feature},
+};
+
+type GeoResult<T> = geozero::error::Result<T>;
+
+/// Build tessellations with vectors.
+pub struct TextTessellatorNew {
+    geo_writer: GeoWriter,
+
+    // output
+    pub quad_buffer: VertexBuffers<ShaderSymbolVertexNew, IndexDataType>,
+    pub features: Vec<Feature>,
+
+    // iteration variables
+    current_index: usize,
+    current_text: Option<String>,
+    current_origin: Option<Box2D<f32, TileSpace>>,
+}
+
+impl TextTessellatorNew {
+    pub fn finish(&mut self) {
+        let data = include_bytes!("../../../data/0-255.pbf");
+        let glyphs = GlyphSet::try_from(data.as_slice()).unwrap();
+
+        let font_stack = vec![
+            "Open Sans Regular".to_string(),
+            "Arial Unicode MS Regular".to_string(),
+        ];
+
+        let layer_name = "layer".to_string();
+
+        let section_options = SectionOptions::new(1.0, font_stack.clone(), None);
+
+        let mut glyph_dependencies = GlyphDependencies::new();
+
+        let tile_id = OverscaledTileID {
+            canonical: CanonicalTileID { x: 0, y: 0, z: 0 },
+            overscaled_z: 0,
+        };
+        let mut parameters = BucketParameters {
+            tile_id: tile_id,
+            mode: MapMode::Continuous,
+            pixel_ratio: 1.0,
+            layer_type: LayerTypeInfo,
+        };
+        let layer_data = SymbolGeometryTileLayer {
+            name: layer_name.clone(),
+            features: vec![SymbolGeometryTileFeature::new(Box::new(
+                VectorGeometryTileFeature {
+                    geometry: vec![GeometryCoordinates(vec![Point2D::new(512, 512)])],
+                },
+            ))],
+        };
+        let layer_properties = vec![LayerProperties {
+            id: layer_name.clone(),
+            layer: SymbolLayer {
+                layout: SymbolLayoutProperties_Unevaluated,
+            },
+        }];
+
+        let image_positions = ImagePositions::new();
+
+        let glyph_map =
+            GlyphPositionMap::from_iter(glyphs.glyphs.iter().map(|(unicode_point, glyph)| {
+                (
+                    *unicode_point as Char16,
+                    GlyphPosition {
+                        rect: Rect::new(
+                            Point2D::new(
+                                glyph.tex_origin_x as u16 + 3,
+                                glyph.tex_origin_y as u16 + 3,
+                            ),
+                            Size2D::new(
+                                glyph.buffered_dimensions().0 as u16,
+                                glyph.buffered_dimensions().1 as u16,
+                            ),
+                        ), // FIXME: verify if this mapping is correct
+                        metrics: GlyphMetrics {
+                            width: glyph.width,
+                            height: glyph.height,
+                            left: glyph.left_bearing,
+                            top: glyph.top_bearing,
+                            advance: glyph.h_advance,
+                        },
+                    },
+                )
+            }));
+
+        let glyph_positions: GlyphPositions =
+            GlyphPositions::from([(FontStackHasher::new(&font_stack), glyph_map)]);
+
+        let glyphs: GlyphMap = GlyphMap::from([(
+            FontStackHasher::new(&font_stack),
+            Glyphs::from_iter(glyphs.glyphs.iter().map(|(unicode_point, glyph)| {
+                (
+                    *unicode_point as Char16,
+                    Some(Glyph {
+                        id: *unicode_point as Char16,
+                        bitmap: Default::default(),
+                        metrics: GlyphMetrics {
+                            width: glyph.width,
+                            height: glyph.height,
+                            left: glyph.left_bearing,
+                            top: glyph.top_bearing,
+                            advance: glyph.h_advance,
+                        },
+                    }),
+                )
+            })),
+        )]);
+
+        let mut layout = SymbolLayout::new(
+            &parameters,
+            &layer_properties,
+            Box::new(layer_data),
+            &mut LayoutParameters {
+                bucket_parameters: &mut parameters.clone(),
+                glyph_dependencies: &mut glyph_dependencies,
+                image_dependencies: &mut Default::default(),
+                available_images: &mut Default::default(),
+            },
+        )
+        .unwrap();
+
+        assert_eq!(glyph_dependencies.len(), 1);
+
+        let empty_image_map = ImageMap::new();
+        layout.prepare_symbols(
+            &glyphs,
+            &glyph_positions,
+            &empty_image_map,
+            &image_positions,
+        );
+
+        let mut output = HashMap::new();
+        layout.create_bucket(
+            image_positions,
+            Box::new(FeatureIndex),
+            &mut output,
+            false,
+            false,
+            &tile_id.canonical,
+        );
+
+        let new_buffer = output.remove(&layer_name).unwrap();
+
+        let mut buffer = VertexBuffers::new();
+        let text_buffer = new_buffer.bucket.text;
+        let SymbolBucketBuffer {
+            shared_vertices,
+            triangles,
+            ..
+        } = text_buffer;
+        buffer.vertices = shared_vertices
+            .iter()
+            .map(|v| ShaderSymbolVertexNew::new(v))
+            .collect();
+        buffer.indices = triangles.indices.iter().map(|i| *i as u32).collect();
+
+        self.quad_buffer = buffer;
+    }
+}
+
+impl Default for TextTessellatorNew {
+    fn default() -> Self {
+        Self {
+            geo_writer: Default::default(),
+            quad_buffer: VertexBuffers::new(),
+            features: vec![],
+            current_index: 0,
+            current_text: None,
+            current_origin: None,
+        }
+    }
+}
+
+impl GeomProcessor for TextTessellatorNew {
+    fn xy(&mut self, x: f64, y: f64, idx: usize) -> GeoResult<()> {
+        self.geo_writer.xy(x, y, idx)
+    }
+    fn point_begin(&mut self, idx: usize) -> GeoResult<()> {
+        self.geo_writer.point_begin(idx)
+    }
+    fn point_end(&mut self, idx: usize) -> GeoResult<()> {
+        self.geo_writer.point_end(idx)
+    }
+    fn multipoint_begin(&mut self, size: usize, idx: usize) -> GeoResult<()> {
+        self.geo_writer.multipoint_begin(size, idx)
+    }
+    fn linestring_begin(&mut self, tagged: bool, size: usize, idx: usize) -> GeoResult<()> {
+        self.geo_writer.linestring_begin(tagged, size, idx)
+    }
+    fn linestring_end(&mut self, tagged: bool, idx: usize) -> GeoResult<()> {
+        self.geo_writer.linestring_end(tagged, idx)
+    }
+    fn multilinestring_begin(&mut self, size: usize, idx: usize) -> GeoResult<()> {
+        self.geo_writer.multilinestring_begin(size, idx)
+    }
+    fn multilinestring_end(&mut self, idx: usize) -> GeoResult<()> {
+        self.geo_writer.multilinestring_end(idx)
+    }
+    fn polygon_begin(&mut self, tagged: bool, size: usize, idx: usize) -> GeoResult<()> {
+        self.geo_writer.polygon_begin(tagged, size, idx)
+    }
+    fn polygon_end(&mut self, tagged: bool, idx: usize) -> GeoResult<()> {
+        self.geo_writer.polygon_end(tagged, idx)
+    }
+    fn multipolygon_begin(&mut self, size: usize, idx: usize) -> GeoResult<()> {
+        self.geo_writer.multipolygon_begin(size, idx)
+    }
+    fn multipolygon_end(&mut self, idx: usize) -> GeoResult<()> {
+        self.geo_writer.multipolygon_end(idx)
+    }
+}
+
+impl PropertyProcessor for TextTessellatorNew {
+    fn property(
+        &mut self,
+        _idx: usize,
+        name: &str,
+        value: &ColumnValue,
+    ) -> geozero::error::Result<bool> {
+        // TODO: Support different tags
+        if name == "name" {
+            match value {
+                ColumnValue::String(str) => {
+                    self.current_text = Some(str.to_string());
+                }
+                _ => {}
+            }
+        }
+        Ok(true)
+    }
+}
+
+impl FeatureProcessor for TextTessellatorNew {
+    fn feature_end(&mut self, _idx: u64) -> geozero::error::Result<()> {
+        let geometry = self.geo_writer.take_geometry();
+
+        match geometry {
+            Some(Geometry::Point(_point)) => {}
+            Some(Geometry::Polygon(_polygon)) => {}
+            Some(Geometry::LineString(_linestring)) => {}
+            Some(Geometry::Line(_))
+            | Some(Geometry::MultiPoint(_))
+            | Some(Geometry::MultiLineString(_))
+            | Some(Geometry::MultiPolygon(_))
+            | Some(Geometry::GeometryCollection(_))
+            | Some(Geometry::Rect(_))
+            | Some(Geometry::Triangle(_)) => {
+                log::debug!("Unsupported geometry in text tesselation")
+            }
+            None => {
+                log::debug!("No geometry in feature")
+            }
+        };
+
+        Ok(())
+    }
+}
diff --git a/maplibre/src/sdf/text.rs b/maplibre/src/sdf/text.rs
new file mode 100644
index 000000000..98a09fcec
--- /dev/null
+++ b/maplibre/src/sdf/text.rs
@@ -0,0 +1,190 @@
+use std::{collections::BTreeMap, convert::TryFrom};
+
+use image::{GenericImage, GenericImageView, GrayImage, ImageBuffer, Luma};
+use lyon::tessellation::{FillVertex, FillVertexConstructor};
+use prost::{DecodeError, Message};
+
+use crate::render::shaders::ShaderSymbolVertex;
+
+pub mod sdf_glyphs {
+    include!(concat!(env!("OUT_DIR"), "/glyphs.rs"));
+}
+
+pub type UnicodePoint = char;
+
+#[derive(Debug)]
+pub struct Glyph {
+    pub codepoint: UnicodePoint,
+    pub width: u32,
+    pub height: u32,
+    pub left_bearing: i32,
+    pub top_bearing: i32,
+    pub h_advance: u32,
+
+    /// x origin coordinate within the packed texture
+    pub tex_origin_x: u32,
+    /// y origin coordinate within the packed texture
+    pub tex_origin_y: u32,
+}
+
+impl Glyph {
+    fn from_pbf(g: sdf_glyphs::Glyph, origin_x: u32, origin_y: u32) -> Self {
+        Self {
+            codepoint: char::try_from(g.id).unwrap(),
+            width: g.width,
+            height: g.height,
+            left_bearing: g.left,
+            top_bearing: g.top,
+            h_advance: g.advance,
+            tex_origin_x: origin_x,
+            tex_origin_y: origin_y,
+        }
+    }
+
+    pub fn buffered_dimensions(&self) -> (u32, u32) {
+        (self.width + 3 * 2, self.height + 3 * 2)
+    }
+    pub fn origin_offset(&self) -> (u32, u32) {
+        (self.tex_origin_x, self.tex_origin_y)
+    }
+    pub fn advance(&self) -> u32 {
+        self.h_advance
+    }
+}
+
+pub struct GlyphSet {
+    texture_bytes: Vec<u8>,
+    texture_dimensions: (usize, usize),
+    pub glyphs: BTreeMap<UnicodePoint, Glyph>,
+}
+
+impl TryFrom<&[u8]> for GlyphSet {
+    type Error = DecodeError;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        Ok(GlyphSet::from(sdf_glyphs::Glyphs::decode(value)?))
+    }
+}
+
+impl From<sdf_glyphs::Glyphs> for GlyphSet {
+    fn from(pbf_glyphs: sdf_glyphs::Glyphs) -> Self {
+        let stacks = pbf_glyphs.stacks;
+        let mut texture: GrayImage = ImageBuffer::new(4096, 4096);
+        let mut last_position = (0, 0);
+        let mut max_height = 0;
+
+        let glyphs = stacks
+            .into_iter()
+            .flat_map(|stack| {
+                stack
+                    .glyphs
+                    .into_iter()
+                    .filter_map(|mut glyph| {
+                        // Save an extra copy operation by taking the bits out directly.
+                        let bitmap = glyph.bitmap.take()?;
+
+                        let glyph = Glyph::from_pbf(glyph, last_position.0, last_position.1);
+
+                        let buffered_width = glyph.width + 3 * 2;
+                        let buffered_height = glyph.height + 3 * 2;
+
+                        let glyph_texture = ImageBuffer::<Luma<u8>, _>::from_vec(
+                            buffered_width,
+                            buffered_height,
+                            bitmap,
+                        )?;
+                        assert_eq!(buffered_height, glyph_texture.height());
+                        assert_eq!(buffered_width, glyph_texture.width());
+
+                        // TODO: wraparound on texture width overflow
+                        texture
+                            .copy_from(&glyph_texture, last_position.0, last_position.1)
+                            .expect("Unable to copy glyph texture.");
+
+                        last_position.0 += glyph_texture.width();
+                        max_height = max_height.max(glyph_texture.height());
+
+                        Some((glyph.codepoint, glyph))
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .collect();
+
+        Self {
+            texture_bytes: texture
+                .view(0, 0, last_position.0, max_height)
+                .pixels()
+                .map(|(_x, _y, p)| p[0])
+                .collect(),
+            texture_dimensions: (last_position.0 as _, max_height as _),
+            glyphs,
+        }
+    }
+}
+
+impl GlyphSet {
+    pub fn get_texture_dimensions(&self) -> (usize, usize) {
+        self.texture_dimensions
+    }
+
+    pub fn get_texture_bytes(&self) -> &[u8] {
+        self.texture_bytes.as_slice()
+    }
+}
+
+pub struct SymbolVertexBuilder {
+    /// Where is the top-left anchor of the glyph box
+    pub glyph_anchor: [f32; 3],
+    /// Where is the top-left anchor of the text box
+    pub text_anchor: [f32; 3],
+    /// Size of sprite-sheet * font_scale
+    pub texture_dimensions: (f32, f32),
+    /// Size of individual glyph * font_scale
+    pub sprite_dimensions: (f32, f32),
+    /// where in the sheet is the sprite * font_scale
+    pub sprite_offset: (f32, f32),
+    pub glyph: bool,
+    pub color: [u8; 4],
+}
+
+impl FillVertexConstructor<ShaderSymbolVertex> for SymbolVertexBuilder {
+    fn new_vertex(&mut self, vertex: FillVertex) -> ShaderSymbolVertex {
+        let vertex_position = vertex.position();
+
+        let sprite_ratio_x = self.sprite_dimensions.0 / self.texture_dimensions.0;
+        let sprite_ratio_y = self.sprite_dimensions.1 / self.texture_dimensions.1;
+
+        let x_offset = self.sprite_offset.0 / self.texture_dimensions.0;
+        let y_offset = self.sprite_offset.1 / self.texture_dimensions.1;
+
+        let tex_coords = [
+            x_offset
+                + ((vertex_position.x - self.glyph_anchor[0]) / self.sprite_dimensions.0)
+                    * sprite_ratio_x,
+            y_offset
+                + ((vertex_position.y - self.glyph_anchor[1]) / self.sprite_dimensions.1)
+                    * sprite_ratio_y,
+        ];
+
+        ShaderSymbolVertex {
+            position: [vertex_position.x, vertex_position.y, 0.],
+            text_anchor: self.text_anchor,
+            is_glyph: if self.glyph { 1 } else { 0 },
+            color: self.color,
+            tex_coords,
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum Anchor {
+    Center,
+    Left,
+    Right,
+    Top,
+    Bottom,
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight,
+}
diff --git a/maplibre/src/sdf/upload_system.rs b/maplibre/src/sdf/upload_system.rs
new file mode 100644
index 000000000..91cbe2601
--- /dev/null
+++ b/maplibre/src/sdf/upload_system.rs
@@ -0,0 +1,132 @@
+//! Uploads data to the GPU which is needed for rendering.
+
+use std::iter;
+
+use crate::{
+    context::MapContext,
+    coords::ViewRegion,
+    render::{
+        eventually::{Eventually, Eventually::Initialized},
+        shaders::{SDFShaderFeatureMetadata, ShaderLayerMetadata},
+        tile_view_pattern::DEFAULT_TILE_SIZE,
+        view_state::ViewStatePadding,
+        Renderer,
+    },
+    sdf::{SymbolBufferPool, SymbolLayerData, SymbolLayersDataComponent},
+    style::Style,
+    tcs::{
+        system::{SystemError, SystemResult},
+        tiles::Tiles,
+    },
+};
+
+pub fn upload_system(
+    MapContext {
+        world,
+        style,
+        view_state,
+        renderer: Renderer { queue, .. },
+        ..
+    }: &mut MapContext,
+) -> SystemResult {
+    let Some(Initialized(symbol_buffer_pool)) = world
+        .resources
+        .query_mut::<&mut Eventually<SymbolBufferPool>>()
+    else {
+        return Err(SystemError::Dependencies);
+    };
+
+    let view_region = view_state.create_view_region(
+        view_state.zoom().zoom_level(DEFAULT_TILE_SIZE),
+        ViewStatePadding::Loose,
+    );
+
+    if let Some(view_region) = &view_region {
+        upload_symbol_layer(
+            symbol_buffer_pool,
+            queue,
+            &mut world.tiles,
+            style,
+            view_region,
+        );
+    }
+
+    Ok(())
+}
+
+// TODO cleanup, duplicated
+fn upload_symbol_layer(
+    symbol_buffer_pool: &mut SymbolBufferPool,
+    queue: &wgpu::Queue,
+    tiles: &mut Tiles,
+    style: &Style,
+    view_region: &ViewRegion,
+) {
+    // Upload all tessellated layers which are in view
+    for coords in view_region.iter() {
+        let Some(vector_layers) = tiles.query_mut::<&SymbolLayersDataComponent>(coords) else {
+            continue;
+        };
+
+        let loaded_layers = symbol_buffer_pool
+            .get_loaded_source_layers_at(coords)
+            .unwrap_or_default();
+
+        let available_layers = vector_layers
+            .layers
+            .iter()
+            .filter(|data| !loaded_layers.contains(data.source_layer.as_str()))
+            .collect::<Vec<_>>();
+
+        for style_layer in &style.layers {
+            let layer_id = &style_layer.id;
+            let source_layer = match style_layer.source_layer.as_ref() {
+                Some(layer) => layer,
+                None => {
+                    log::trace!("style layer {layer_id} does not have a source layer");
+                    continue;
+                }
+            };
+
+            let Some(SymbolLayerData {
+                coords,
+                features,
+                //buffer,
+                new_buffer: buffer,
+                ..
+            }) = available_layers
+                .iter()
+                .find(|layer| source_layer.as_str() == layer.source_layer)
+            else {
+                continue;
+            };
+
+            // Assign every feature in the layer the color from the style
+            let feature_metadata = iter::repeat(SDFShaderFeatureMetadata { opacity: 0.0 })
+                .take(
+                    features
+                        .last()
+                        .map(|feature| feature.indices.end)
+                        .unwrap_or_default(),
+                )
+                .collect::<Vec<_>>();
+
+            // FIXME avoid uploading empty indices
+            if buffer.buffer.indices.is_empty() {
+                continue;
+            }
+
+            log::debug!("Allocating geometry at {coords}");
+            symbol_buffer_pool.allocate_layer_geometry(
+                queue,
+                *coords,
+                style_layer.clone(),
+                buffer,
+                ShaderLayerMetadata {
+                    z_index: style_layer.index as f32,
+                },
+                &feature_metadata,
+            );
+        }
+    }
+}
diff --git a/maplibre/src/style/layer.rs b/maplibre/src/style/layer.rs
index 96593cc74..33e99a0c1 100644
--- a/maplibre/src/style/layer.rs
+++ b/maplibre/src/style/layer.rs
@@ -1,13 +1,14 @@
 //! Vector tile layer drawing utilities.
 
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    hash::{Hash, Hasher},
+};
 
 use cint::{Alpha, EncodedSrgb};
 use csscolorparser::Color;
 use serde::{Deserialize, Serialize};
 
-use crate::style::raster::RasterLayer;
-
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BackgroundPaint {
     #[serde(rename = "background-color")]
@@ -26,12 +27,68 @@ pub struct FillPaint {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct LinePaint {
-    #[serde(rename = "line-color")]
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "line-color", skip_serializing_if = "Option::is_none")]
     pub line_color: Option<Color>,
     // TODO a lot
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum RasterResampling {
+    #[serde(rename = "linear")]
+    Linear,
+    #[serde(rename = "nearest")]
+    Nearest,
+}
+
+/// Raster tile layer description
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct RasterPaint {
+    #[serde(rename = "raster-brightness-max")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_brightness_max: Option<f32>,
+    #[serde(rename = "raster-brightness-min")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_brightness_min: Option<f32>,
+    #[serde(rename = "raster-contrast")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_contrast: Option<f32>,
+    #[serde(rename = "raster-fade-duration")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_fade_duration: Option<u32>,
+    #[serde(rename = "raster-hue-rotate")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_hue_rotate: Option<f32>,
+    #[serde(rename = "raster-opacity")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_opacity: Option<f32>,
+    #[serde(rename = "raster-resampling")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_resampling: Option<RasterResampling>,
+    #[serde(rename = "raster-saturation")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raster_saturation: Option<f32>,
+}
+
+impl Default for RasterPaint {
+    fn default() -> Self {
+        RasterPaint {
+            raster_brightness_max: Some(1.0),
+            raster_brightness_min: Some(0.0),
+            raster_contrast: Some(0.0),
+            raster_fade_duration: Some(0),
+            raster_hue_rotate: Some(0.0),
+            raster_opacity: Some(1.0),
+            raster_resampling: Some(RasterResampling::Linear),
+            raster_saturation: Some(0.0),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct SymbolPaint {
+    // TODO a lot
+}
+
 /// The different types of paints.
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(tag = "type", content = "paint")]
@@ -43,7 +100,9 @@ pub enum LayerPaint {
     #[serde(rename = "fill")]
     Fill(FillPaint),
     #[serde(rename = "raster")]
-    Raster(RasterLayer),
+    Raster(RasterPaint),
+    #[serde(rename = "symbol")]
+    Symbol(SymbolPaint),
 }
 
 impl LayerPaint {
@@ -56,6 +115,7 @@ impl LayerPaint {
             LayerPaint::Line(paint) => paint.line_color.as_ref().map(|color| color.clone().into()),
             LayerPaint::Fill(paint) => paint.fill_color.as_ref().map(|color| color.clone().into()),
             LayerPaint::Raster(_) => None,
+            LayerPaint::Symbol(_) => None,
         }
     }
 }
@@ -65,7 +125,7 @@ impl LayerPaint {
 pub struct StyleLayer {
     #[serde(skip)]
     pub index: u32, // FIXME: How is this initialized?
-    pub id: String,
+    pub id: String, // todo make sure that ids are unique. Styles with non-unique layer ids must not exist
     // TODO filter
     // TODO layout
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -83,6 +143,19 @@ pub struct StyleLayer {
     pub source_layer: Option<String>,
 }
 
+impl Eq for StyleLayer {}
+impl PartialEq for StyleLayer {
+    fn eq(&self, other: &Self) -> bool {
+        self.id.eq(&other.id)
+    }
+}
+
+impl Hash for StyleLayer {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.id.hash(state)
+    }
+}
+
 impl Default for StyleLayer {
     fn default() -> Self {
         Self {
diff --git a/maplibre/src/style/mod.rs b/maplibre/src/style/mod.rs
index 7528e0fad..e95b1f694 100644
--- a/maplibre/src/style/mod.rs
+++ b/maplibre/src/style/mod.rs
@@ -1,9 +1,232 @@
 //! Vector tile format styling.
 
+use std::{collections::HashMap, str::FromStr};
+
 pub use cint::*;
-pub use style::*;
+use csscolorparser::Color;
+use serde::{Deserialize, Serialize};
+
+use crate::style::{
+    layer::{FillPaint, LayerPaint, LinePaint, RasterPaint, StyleLayer, SymbolPaint},
+    source::Source,
+};
 
 pub mod layer;
-pub mod raster;
 pub mod source;
-mod style;
+
+/// Stores the style for a multi-layered map.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Style {
+    pub version: u16,
+    pub name: String,
+    pub metadata: HashMap<String, String>,
+    pub sources: HashMap<String, Source>,
+    pub layers: Vec<StyleLayer>,
+    pub center: Option<[f64; 2]>, // TODO: Use LatLon type here
+    pub zoom: Option<f64>,
+    pub pitch: Option<f64>,
+}
+
+/// Default style for https://openmaptiles.org/schema/
+impl Default for Style {
+    fn default() -> Self {
+        Style {
+            version: 8,
+            name: "Default Style".to_string(),
+            metadata: Default::default(),
+            sources: Default::default(),
+            center: Some([50.85045, 4.34878]),
+            pitch: Some(0.0),
+            zoom: Some(13.0),
+            layers: vec![
+                StyleLayer {
+                    index: 0,
+                    id: "park".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Fill(FillPaint {
+                        fill_color: Some(Color::from_str("#c8facc").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("park".to_string()),
+                },
+                StyleLayer {
+                    index: 1,
+                    id: "landuse".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Fill(FillPaint {
+                        fill_color: Some(Color::from_str("#e0dfdf").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("landuse".to_string()),
+                },
+                StyleLayer {
+                    index: 2,
+                    id: "landcover".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Fill(FillPaint {
+                        fill_color: Some(Color::from_str("#aedfa3").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("landcover".to_string()),
+                },
+                StyleLayer {
+                    index: 3,
+                    id: "transportation".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Line(LinePaint {
+                        line_color: Some(Color::from_str("#ffffff").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("transportation".to_string()),
+                },
+                StyleLayer {
+                    index: 4,
+                    id: "building".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Fill(FillPaint {
+                        fill_color: Some(Color::from_str("#d9d0c9").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("building".to_string()),
+                },
+                StyleLayer {
+                    index: 4,
+                    id: "water".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Fill(FillPaint {
+                        fill_color: Some(Color::from_str("#aad3df").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("water".to_string()),
+                },
+                StyleLayer {
+                    index: 6,
+                    id: "waterway".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Fill(FillPaint {
+                        fill_color: Some(Color::from_str("#aad3df").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("waterway".to_string()),
+                },
+                StyleLayer {
+                    index: 7,
+                    id: "boundary".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Line(LinePaint {
+                        line_color: Some(Color::from_str("black").unwrap()),
+                    })),
+                    source: None,
+                    source_layer: Some("boundary".to_string()),
+                },
+                StyleLayer {
+                    index: 8,
+                    id: "raster".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Raster(RasterPaint::default())),
+                    source: None,
+                    source_layer: None,
+                },
+                StyleLayer {
+                    index: 9,
+                    id: "text".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Symbol(SymbolPaint {})),
+                    source: None,
+                    source_layer: Some("place".to_string()),
+                },
+                StyleLayer {
+                    index: 10,
+                    id: "text".to_string(),
+                    maxzoom: None,
+                    minzoom: None,
+                    metadata: None,
+                    paint: Some(LayerPaint::Symbol(SymbolPaint {})),
+                    source: None,
+                    source_layer: Some("transportation_name-disabled".to_string()),
+                },
+            ],
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_reading() {
+        // language=JSON
+        let style_json_str = r##"
+        {
+          "version": 8,
+          "name": "Test Style",
+          "metadata": {},
+          "sources": {
+            "openmaptiles": {
+              "type": "vector",
+              "url": "https://maps.tuerantuer.org/europe_germany/tiles.json"
+            }
+          },
+          "layers": [
+            {
+              "id": "background",
+              "type": "background",
+              "paint": {"background-color": "rgb(239,239,239)"}
+            },
+            {
+              "id": "transportation",
+              "type": "line",
+              "source": "openmaptiles",
+              "source-layer": "transportation",
+              "paint": {
+                "line-color": "#3D3D3D"
+              }
+            },
+            {
+              "id": "boundary",
+              "type": "line",
+              "source": "openmaptiles",
+              "source-layer": "boundary",
+              "paint": {
+                "line-color": "#3D3D3D"
+              }
+            },
+            {
+              "id": "building",
+              "minzoom": 14,
+              "maxzoom": 15,
+              "type": "fill",
+              "source": "openmaptiles",
+              "source-layer": "building",
+              "paint": {
+                "line-color": "#3D3D3D"
+              }
+            }
+          ]
+        }
+        "##;
+
+        let _style: Style = serde_json::from_str(style_json_str).unwrap();
+    }
+}
diff --git a/maplibre/src/style/raster.rs b/maplibre/src/style/raster.rs
deleted file mode 100644
index d615550d5..000000000
--- a/maplibre/src/style/raster.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! Raster tile layer description
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum RasterResampling {
-    #[serde(rename = "linear")]
-    Linear,
-    #[serde(rename = "nearest")]
-    Nearest,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct RasterLayer {
-    #[serde(rename = "raster-brightness-max")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_brightness_max: Option<f32>,
-    #[serde(rename = "raster-brightness-min")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_brightness_min: Option<f32>,
-    #[serde(rename = "raster-contrast")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_contrast: Option<f32>,
-    #[serde(rename = "raster-fade-duration")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_fade_duration: Option<u32>,
-    #[serde(rename = "raster-hue-rotate")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_hue_rotate: Option<f32>,
-    #[serde(rename = "raster-opacity")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_opacity: Option<f32>,
-    #[serde(rename = "raster-resampling")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_resampling: Option<RasterResampling>,
-    #[serde(rename = "raster-saturation")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raster_saturation: Option<f32>,
-}
-
-impl Default for RasterLayer {
-    fn default() -> Self {
-        RasterLayer {
-            raster_brightness_max: Some(1.0),
-            raster_brightness_min: Some(0.0),
-            raster_contrast: Some(0.0),
-            raster_fade_duration: Some(0),
-            raster_hue_rotate: Some(0.0),
-            raster_opacity: Some(1.0),
-            raster_resampling: Some(RasterResampling::Linear),
-            raster_saturation: Some(0.0),
-        }
-    }
-}
diff --git a/maplibre/src/style/style.rs b/maplibre/src/style/style.rs
deleted file mode 100644
index 104c716a6..000000000
--- a/maplibre/src/style/style.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-//! Default vector tile styles configuration.
-
-use std::{collections::HashMap, str::FromStr};
-
-use csscolorparser::Color;
-use serde::{Deserialize, Serialize};
-
-use crate::style::{
-    layer::{FillPaint, LayerPaint, LinePaint, StyleLayer},
-    raster::RasterLayer,
-    source::Source,
-};
-
-/// Stores the style for a multi-layered map.
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Style {
-    pub version: u16,
-    pub name: String,
-    pub metadata: HashMap<String, String>,
-    pub sources: HashMap<String, Source>,
-    pub layers: Vec<StyleLayer>,
-    pub center: Option<[f64; 2]>, // TODO: Use LatLon type here
-    pub zoom: Option<f64>,
-    pub pitch: Option<f64>,
-}
-
-impl Default for Style {
-    fn default() -> Self {
-        Style {
-            version: 8,
-            name: "Default Style".to_string(),
-            metadata: Default::default(),
-            sources: Default::default(),
-            center: Some([50.85045, 4.34878]),
-            pitch: Some(0.0),
-            zoom: Some(13.0),
-            layers: vec![
-                StyleLayer {
-                    index: 0,
-                    id: "park".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Fill(FillPaint {
-                        fill_color: Some(Color::from_str("#c8facc").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("park".to_string()),
-                },
-                StyleLayer {
-                    index: 1,
-                    id: "landuse".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Fill(FillPaint {
-                        fill_color: Some(Color::from_str("#e0dfdf").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("landuse".to_string()),
-                },
-                StyleLayer {
-                    index: 2,
-                    id: "landcover".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Fill(FillPaint {
-                        fill_color: Some(Color::from_str("#aedfa3").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("landcover".to_string()),
-                },
-                StyleLayer {
-                    index: 3,
-                    id: "transportation".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Line(LinePaint {
-                        line_color: Some(Color::from_str("#ffffff").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("transportation".to_string()),
-                },
-                StyleLayer {
-                    index: 4,
-                    id: "building".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Fill(FillPaint {
-                        fill_color: Some(Color::from_str("#d9d0c9").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("building".to_string()),
-                },
-                StyleLayer {
-                    index: 4,
-                    id: "water".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Fill(FillPaint {
-                        fill_color: Some(Color::from_str("#aad3df").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("water".to_string()),
-                },
-                StyleLayer {
-                    index: 6,
-                    id: "waterway".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Fill(FillPaint {
-                        fill_color: Some(Color::from_str("#aad3df").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("waterway".to_string()),
-                },
-                StyleLayer {
-                    index: 7,
-                    id: "boundary".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Line(LinePaint {
-                        line_color: Some(Color::from_str("black").unwrap()),
-                    })),
-                    source: None,
-                    source_layer: Some("boundary".to_string()),
-                },
-                StyleLayer {
-                    index: 8,
-                    id: "raster".to_string(),
-                    maxzoom: None,
-                    minzoom: None,
-                    metadata: None,
-                    paint: Some(LayerPaint::Raster(RasterLayer::default())),
-                    source: None,
-                    source_layer: Some("raster".to_string()),
-                },
-            ],
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_reading() {
-        // language=JSON
-        let style_json_str = r##"
-        {
-          "version": 8,
-          "name": "Test Style",
-          "metadata": {},
-          "sources": {
-            "openmaptiles": {
-              "type": "vector",
-              "url": "https://maps.tuerantuer.org/europe_germany/tiles.json"
-            }
-          },
-          "layers": [
-            {
-              "id": "background",
-              "type": "background",
-              "paint": {"background-color": "rgb(239,239,239)"}
-            },
-            {
-              "id": "transportation",
-              "type": "line",
-              "source": "openmaptiles",
-              "source-layer": "transportation",
-              "paint": {
-                "line-color": "#3D3D3D"
-              }
-            },
-            {
-              "id": "boundary",
-              "type": "line",
-              "source": "openmaptiles",
-              "source-layer": "boundary",
-              "paint": {
-                "line-color": "#3D3D3D"
-              }
-            },
-            {
-              "id": "building",
-              "minzoom": 14,
-              "maxzoom": 15,
-              "type": "fill",
-              "source": "openmaptiles",
-              "source-layer": "building",
-              "paint": {
-                "line-color": "#3D3D3D"
-              }
-            }
-          ]
-        }
-        "##;
-
-        let _style: Style = serde_json::from_str(style_json_str).unwrap();
-    }
-}
diff --git a/maplibre/src/tcs/system/function.rs b/maplibre/src/tcs/system/function.rs
index 5a9ed3a78..5c02113e7 100644
--- a/maplibre/src/tcs/system/function.rs
+++ b/maplibre/src/tcs/system/function.rs
@@ -1,6 +1,9 @@
 use std::{any::type_name, borrow::Cow};
 
-use crate::{context::MapContext, tcs::system::System};
+use crate::{
+    context::MapContext,
+    tcs::system::{System, SystemResult},
+};
 
 /// Conversion trait to turn something into a [`System`].
 ///
@@ -18,20 +21,20 @@ pub struct FunctionSystem<F> {
 
 impl<F> System for FunctionSystem<F>
 where
-    F: FnMut(&mut MapContext) + 'static,
+    F: FnMut(&mut MapContext) -> SystemResult + 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         type_name::<F>().into()
     }
 
-    fn run(&mut self, context: &mut MapContext) {
+    fn run(&mut self, context: &mut MapContext) -> SystemResult {
         (self.func)(context)
     }
 }
 
 impl<F> IntoSystem for F
 where
-    F: FnMut(&mut MapContext) + 'static,
+    F: FnMut(&mut MapContext) -> SystemResult + 'static,
 {
     type System = FunctionSystem<F>;
 
diff --git a/maplibre/src/tcs/system/mod.rs b/maplibre/src/tcs/system/mod.rs
index 24e2b6c73..410907661 100644
--- a/maplibre/src/tcs/system/mod.rs
+++ b/maplibre/src/tcs/system/mod.rs
@@ -1,16 +1,28 @@
 use std::borrow::Cow;
 
+use thiserror::Error;
+
 use crate::{context::MapContext, tcs::system::function::IntoSystem};
 
 mod function;
 pub mod stage;
 
+#[derive(Error, Debug)]
+pub enum SystemError {
+    #[error("renderer was setup wrong")]
+    Setup,
+    #[error("dependencies were not resolvable")]
+    Dependencies,
+}
+
+pub type SystemResult = Result<(), SystemError>;
+
 /// An system that can be added to a [`Schedule`](crate::schedule::Schedule)
 pub trait System: 'static {
     /// Returns the system's name.
     fn name(&self) -> Cow<'static, str>;
 
-    fn run(&mut self, context: &mut MapContext);
+    fn run(&mut self, context: &mut MapContext) -> SystemResult;
 }
 
 /// A convenience type alias for a boxed [`System`] trait object.
diff --git a/maplibre/src/tcs/system/stage.rs b/maplibre/src/tcs/system/stage.rs
index 67531b14a..882e00538 100644
--- a/maplibre/src/tcs/system/stage.rs
+++ b/maplibre/src/tcs/system/stage.rs
@@ -1,6 +1,6 @@
 use crate::{
     context::MapContext,
-    schedule::Stage,
+    schedule::{Stage, StageResult},
     tcs::system::{IntoSystemContainer, SystemContainer},
 };
 
@@ -23,12 +23,13 @@ impl SystemStage {
 }
 
 impl Stage for SystemStage {
-    fn run(&mut self, context: &mut MapContext) {
+    fn run(&mut self, context: &mut MapContext) -> StageResult {
         for container in &mut self.systems {
             #[cfg(feature = "trace")]
             let _span =
                 tracing::info_span!("system", name = container.system.name().as_ref()).entered();
-            container.system.run(context)
+            container.system.run(context)?
         }
+        Ok(())
     }
 }
diff --git a/maplibre/src/tessellation/mod.rs b/maplibre/src/tessellation/mod.rs
deleted file mode 100644
index 56bfce8be..000000000
--- a/maplibre/src/tessellation/mod.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-//! Tessellation for lines and polygons is implemented here.
-
-use bytemuck::Pod;
-use lyon::tessellation::{
-    FillVertex, FillVertexConstructor, StrokeVertex, StrokeVertexConstructor, VertexBuffers,
-};
-
-use crate::render::ShaderVertex;
-
-pub mod zero_tessellator;
-
-const DEFAULT_TOLERANCE: f32 = 0.02;
-
-/// Vertex buffers index data type.
-pub type IndexDataType = u32; // Must match INDEX_FORMAT
-
-/// Constructor for Fill and Stroke vertices.
-pub struct VertexConstructor {}
-
-impl FillVertexConstructor<ShaderVertex> for VertexConstructor {
-    fn new_vertex(&mut self, vertex: FillVertex) -> ShaderVertex {
-        ShaderVertex::new(vertex.position().to_array(), [0.0, 0.0])
-    }
-}
-
-impl StrokeVertexConstructor<ShaderVertex> for VertexConstructor {
-    fn new_vertex(&mut self, vertex: StrokeVertex) -> ShaderVertex {
-        ShaderVertex::new(
-            vertex.position_on_path().to_array(),
-            vertex.normal().to_array(),
-        )
-    }
-}
-
-/// Vertex buffer which includes additional padding to fulfill the `wgpu::COPY_BUFFER_ALIGNMENT`.
-#[derive(Clone)]
-pub struct OverAlignedVertexBuffer<V, I> {
-    pub buffer: VertexBuffers<V, I>,
-    pub usable_indices: u32,
-}
-
-impl<V, I> OverAlignedVertexBuffer<V, I> {
-    pub fn empty() -> Self {
-        Self {
-            buffer: VertexBuffers::with_capacity(0, 0),
-            usable_indices: 0,
-        }
-    }
-
-    pub fn from_iters<IV, II>(vertices: IV, indices: II, usable_indices: u32) -> Self
-    where
-        IV: IntoIterator<Item = V>,
-        II: IntoIterator<Item = I>,
-        IV::IntoIter: ExactSizeIterator,
-        II::IntoIter: ExactSizeIterator,
-    {
-        let vertices = vertices.into_iter();
-        let indices = indices.into_iter();
-        let mut buffers = VertexBuffers::with_capacity(vertices.len(), indices.len());
-        buffers.vertices.extend(vertices);
-        buffers.indices.extend(indices);
-        Self {
-            buffer: buffers,
-            usable_indices,
-        }
-    }
-}
-
-impl<V: Pod, I: Pod> From<VertexBuffers<V, I>> for OverAlignedVertexBuffer<V, I> {
-    fn from(mut buffer: VertexBuffers<V, I>) -> Self {
-        let usable_indices = buffer.indices.len() as u32;
-        buffer.align_vertices();
-        buffer.align_indices();
-        Self {
-            buffer,
-            usable_indices,
-        }
-    }
-}
-
-trait Align<V: Pod, I: Pod> {
-    fn align_vertices(&mut self);
-    fn align_indices(&mut self);
-}
-
-impl<V: Pod, I: Pod> Align<V, I> for VertexBuffers<V, I> {
-    fn align_vertices(&mut self) {
-        let align = wgpu::COPY_BUFFER_ALIGNMENT;
-        let stride = std::mem::size_of::<ShaderVertex>() as wgpu::BufferAddress;
-        let unpadded_bytes = self.vertices.len() as wgpu::BufferAddress * stride;
-        let padding_bytes = (align - unpadded_bytes % align) % align;
-
-        if padding_bytes != 0 {
-            panic!(
-                "vertices are always aligned to wgpu::COPY_BUFFER_ALIGNMENT \
-                    because GpuVertexUniform is aligned"
-            )
-        }
-    }
-
-    fn align_indices(&mut self) {
-        let align = wgpu::COPY_BUFFER_ALIGNMENT;
-        let stride = std::mem::size_of::<I>() as wgpu::BufferAddress;
-        let unpadded_bytes = self.indices.len() as wgpu::BufferAddress * stride;
-        let padding_bytes = (align - unpadded_bytes % align) % align;
-        let overpad = (padding_bytes + stride - 1) / stride; // Divide by stride but round up
-
-        for _ in 0..overpad {
-            self.indices.push(I::zeroed());
-        }
-    }
-}
diff --git a/maplibre/src/util/fps_meter.rs b/maplibre/src/util/fps_meter.rs
index 65b99568a..30d95a98f 100644
--- a/maplibre/src/util/fps_meter.rs
+++ b/maplibre/src/util/fps_meter.rs
@@ -31,7 +31,7 @@ impl FPSMeter {
         self.frame_count += 1;
         let now = Instant::now();
         if now >= self.next_report {
-            log::info!("{} FPS", self.frame_count);
+            log::warn!("{} FPS", self.frame_count);
             self.frame_count = 0;
             self.next_report = now + Duration::from_secs(1);
         }
diff --git a/maplibre/src/util/mod.rs b/maplibre/src/util/mod.rs
index 5310ca87d..8d159447a 100644
--- a/maplibre/src/util/mod.rs
+++ b/maplibre/src/util/mod.rs
@@ -17,6 +17,7 @@ pub trait SignificantlyDifferent<Rhs: ?Sized = Self> {
     fn ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool;
 }
 
+#[derive(Clone)]
 pub struct ChangeObserver<T> {
     inner: T,
     reference_value: Option<T>,
diff --git a/maplibre/src/vector/mod.rs b/maplibre/src/vector/mod.rs
index 71d807dff..bdfa85b6f 100644
--- a/maplibre/src/vector/mod.rs
+++ b/maplibre/src/vector/mod.rs
@@ -1,5 +1,11 @@
 use std::{marker::PhantomData, ops::Deref, rc::Rc};
 
+pub use process_vector::*;
+pub use transferables::{
+    DefaultVectorTransferables, LayerIndexed, LayerMissing, LayerTessellated,
+    SymbolLayerTessellated, TileTessellated, VectorTransferables,
+};
+
 use crate::{
     coords::WorldTileCoords,
     environment::Environment,
@@ -7,16 +13,20 @@ use crate::{
     plugin::Plugin,
     render::{
         eventually::Eventually,
-        shaders::{ShaderFeatureStyle, ShaderLayerMetadata},
+        graph::RenderGraph,
+        shaders::{FillShaderFeatureMetadata, ShaderLayerMetadata},
         tile_view_pattern::{HasTile, ViewTileSources},
         RenderStageLabel, ShaderVertex,
     },
     schedule::Schedule,
     tcs::{system::SystemContainer, tiles::TileComponent, world::World},
-    tessellation::{IndexDataType, OverAlignedVertexBuffer},
     vector::{
-        populate_world_system::PopulateWorldSystem, queue_system::queue_system,
-        request_system::RequestSystem, resource::BufferPool, resource_system::resource_system,
+        populate_world_system::PopulateWorldSystem,
+        queue_system::queue_system,
+        request_system::RequestSystem,
+        resource::BufferPool,
+        resource_system::resource_system,
+        tessellation::{IndexDataType, OverAlignedVertexBuffer},
         upload_system::upload_system,
     },
 };
@@ -26,18 +36,13 @@ mod process_vector;
 mod queue_system;
 mod render_commands;
 mod request_system;
-mod resource;
+pub(crate) mod resource;
 mod resource_system;
-mod transferables;
+pub(crate) mod transferables;
 mod upload_system;
 
-pub use process_vector::*;
-pub use transferables::{
-    DefaultVectorTransferables, LayerIndexed, LayerMissing, LayerTessellated, TileTessellated,
-    VectorTransferables,
-};
-
-use crate::render::graph::RenderGraph;
+// Public due to bechmarks
+pub mod tessellation;
 
 struct VectorPipeline(wgpu::RenderPipeline);
 impl Deref for VectorPipeline {
@@ -54,7 +59,7 @@ pub type VectorBufferPool = BufferPool<
     ShaderVertex,
     IndexDataType,
     ShaderLayerMetadata,
-    ShaderFeatureStyle,
+    FillShaderFeatureMetadata,
 >;
 
 pub struct VectorPlugin<T>(PhantomData<T>);
@@ -71,7 +76,7 @@ struct VectorTilesDone;
 
 impl HasTile for VectorTilesDone {
     fn has_tile(&self, coords: WorldTileCoords, world: &World) -> bool {
-        let Some(vector_layers_indices) = world.tiles.query::<&VectorLayersDataComponent>(coords)
+        let Some(vector_layers_indices) = world.tiles.query::<&VectorLayerBucketComponent>(coords)
         else {
             return false;
         };
@@ -113,7 +118,7 @@ impl<E: Environment, T: VectorTransferables> Plugin<E> for VectorPlugin<T> {
     }
 }
 
-pub struct AvailableVectorLayerData {
+pub struct AvailableVectorLayerBucket {
     pub coords: WorldTileCoords,
     pub source_layer: String,
     pub buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
@@ -121,20 +126,20 @@ pub struct AvailableVectorLayerData {
     pub feature_indices: Vec<u32>,
 }
 
-pub struct MissingVectorLayerData {
+pub struct MissingVectorLayerBucket {
     pub coords: WorldTileCoords,
     pub source_layer: String,
 }
 
-pub enum VectorLayerData {
-    Available(AvailableVectorLayerData),
-    Missing(MissingVectorLayerData),
+pub enum VectorLayerBucket {
+    AvailableLayer(AvailableVectorLayerBucket),
+    Missing(MissingVectorLayerBucket),
 }
 
 #[derive(Default)]
-pub struct VectorLayersDataComponent {
+pub struct VectorLayerBucketComponent {
     pub done: bool,
-    pub layers: Vec<VectorLayerData>,
+    pub layers: Vec<VectorLayerBucket>,
 }
 
-impl TileComponent for VectorLayersDataComponent {}
+impl TileComponent for VectorLayerBucketComponent {}
diff --git a/maplibre/src/vector/populate_world_system.rs b/maplibre/src/vector/populate_world_system.rs
index 29a1d569a..1747bfd4b 100644
--- a/maplibre/src/vector/populate_world_system.rs
+++ b/maplibre/src/vector/populate_world_system.rs
@@ -5,8 +5,8 @@ use crate::{
     environment::Environment,
     io::apc::{AsyncProcedureCall, Message},
     kernel::Kernel,
-    tcs::system::System,
-    vector::{transferables::*, VectorLayerData, VectorLayersDataComponent},
+    tcs::system::{System, SystemResult},
+    vector::{transferables::*, VectorLayerBucket, VectorLayerBucketComponent},
 };
 
 pub struct PopulateWorldSystem<E: Environment, T> {
@@ -28,7 +28,7 @@ impl<E: Environment, T: VectorTransferables> System for PopulateWorldSystem<E, T
         "populate_world_system".into()
     }
 
-    fn run(&mut self, MapContext { world, .. }: &mut MapContext) {
+    fn run(&mut self, MapContext { world, .. }: &mut MapContext) -> SystemResult {
         for message in self.kernel.apc().receive(|message| {
             message.has_tag(T::TileTessellated::message_tag())
                 || message.has_tag(T::LayerMissing::message_tag())
@@ -40,7 +40,7 @@ impl<E: Environment, T: VectorTransferables> System for PopulateWorldSystem<E, T
                 let message = message.into_transferable::<T::TileTessellated>();
                 let Some(component) = world
                     .tiles
-                    .query_mut::<&mut VectorLayersDataComponent>(message.coords())
+                    .query_mut::<&mut VectorLayerBucketComponent>(message.coords())
                 else {
                     continue;
                 };
@@ -50,14 +50,14 @@ impl<E: Environment, T: VectorTransferables> System for PopulateWorldSystem<E, T
                 let message = message.into_transferable::<T::LayerMissing>();
                 let Some(component) = world
                     .tiles
-                    .query_mut::<&mut VectorLayersDataComponent>(message.coords())
+                    .query_mut::<&mut VectorLayerBucketComponent>(message.coords())
                 else {
                     continue;
                 };
 
                 component
                     .layers
-                    .push(VectorLayerData::Missing(message.to_layer()));
+                    .push(VectorLayerBucket::Missing(message.to_bucket()));
             } else if message.has_tag(T::LayerTessellated::message_tag()) {
                 let message = message.into_transferable::<T::LayerTessellated>();
                 // FIXME: Handle points!
@@ -67,14 +67,14 @@ impl<E: Environment, T: VectorTransferables> System for PopulateWorldSystem<E, T
 
                 let Some(component) = world
                     .tiles
-                    .query_mut::<&mut VectorLayersDataComponent>(message.coords())
+                    .query_mut::<&mut VectorLayerBucketComponent>(message.coords())
                 else {
                     continue;
                 };
 
                 component
                     .layers
-                    .push(VectorLayerData::Available(message.to_layer()));
+                    .push(VectorLayerBucket::AvailableLayer(message.to_bucket()));
             } else if message.has_tag(T::LayerIndexed::message_tag()) {
                 let message = message.into_transferable::<T::LayerIndexed>();
                 world
@@ -83,5 +83,6 @@ impl<E: Environment, T: VectorTransferables> System for PopulateWorldSystem<E, T
                     .index_tile(&message.coords(), message.to_tile_index());
             }
         }
+        Ok(())
     }
 }
diff --git a/maplibre/src/vector/process_vector.rs b/maplibre/src/vector/process_vector.rs
index 79ff7a3bc..a1c4499ca 100644
--- a/maplibre/src/vector/process_vector.rs
+++ b/maplibre/src/vector/process_vector.rs
@@ -12,10 +12,18 @@ use crate::{
         apc::{Context, SendError},
         geometry_index::{IndexProcessor, IndexedGeometry, TileIndex},
     },
-    render::ShaderVertex,
-    tessellation::{zero_tessellator::ZeroTessellator, IndexDataType, OverAlignedVertexBuffer},
-    vector::transferables::{
-        LayerIndexed, LayerMissing, LayerTessellated, TileTessellated, VectorTransferables,
+    render::{
+        shaders::{ShaderSymbolVertex, ShaderSymbolVertexNew},
+        ShaderVertex,
+    },
+    sdf::{tessellation::TextTessellator, tessellation_new::TextTessellatorNew, Feature},
+    style::layer::{LayerPaint, StyleLayer},
+    vector::{
+        tessellation::{IndexDataType, OverAlignedVertexBuffer, ZeroTessellator},
+        transferables::{
+            LayerIndexed, LayerMissing, LayerTessellated, SymbolLayerTessellated, TileTessellated,
+            VectorTransferables,
+        },
     },
 };
 
@@ -32,7 +40,7 @@ pub enum ProcessVectorError {
 /// A request for a tile at the given coordinates and in the given layers.
 pub struct VectorTileRequest {
     pub coords: WorldTileCoords,
-    pub layers: HashSet<String>,
+    pub layers: HashSet<StyleLayer>,
 }
 
 pub fn process_vector_tile<T: VectorTransferables, C: Context>(
@@ -40,54 +48,91 @@ pub fn process_vector_tile<T: VectorTransferables, C: Context>(
     tile_request: VectorTileRequest,
     context: &mut ProcessVectorContext<T, C>,
 ) -> Result<(), ProcessVectorError> {
-    // Decode
-
     let mut tile = geozero::mvt::Tile::decode(data)
         .map_err(|e| ProcessVectorError::Decoding(e.to_string().into()))?;
 
-    // Available
-
+    // Report available layers
     let coords = &tile_request.coords;
 
-    for layer in &mut tile.layers {
-        let cloned_layer = layer.clone();
-        let layer_name: &str = &cloned_layer.name;
-        if !tile_request.layers.contains(layer_name) {
-            continue;
-        }
+    for style_layer in &tile_request.layers {
+        let id = &style_layer.id;
+        if let (Some(paint), Some(source_layer)) = (&style_layer.paint, &style_layer.source_layer) {
+            if let Some(layer) = tile
+                .layers
+                .iter_mut()
+                .find(|layer| &layer.name == source_layer)
+            {
+                let original_layer = layer.clone();
 
-        let mut tessellator = ZeroTessellator::<IndexDataType>::default();
-        if let Err(e) = layer.process(&mut tessellator) {
-            context.layer_missing(coords, layer_name)?;
+                match paint {
+                    LayerPaint::Line(_) | LayerPaint::Fill(_) => {
+                        let mut tessellator = ZeroTessellator::<IndexDataType>::default();
 
-            tracing::error!("layer {layer_name} at {coords} tesselation failed {e:?}");
+                        if let Err(e) = layer.process(&mut tessellator) {
+                            context.layer_missing(coords, &source_layer)?;
+
+                            tracing::error!("tesselation for layer source {source_layer} at {coords} failed {e:?}");
+                        } else {
+                            context.layer_tesselation_finished(
+                                coords,
+                                tessellator.buffer.into(),
+                                tessellator.feature_indices,
+                                original_layer,
+                            )?;
+                        }
+                    }
+                    LayerPaint::Symbol(_) => {
+                        // TODO
+                        let mut tessellator = TextTessellator::<IndexDataType>::default();
+                        let mut tessellator_new = TextTessellatorNew::default();
+
+                        if let Err(e) = layer.process(&mut tessellator_new) {
+                            context.layer_missing(coords, &source_layer)?;
+
+                            tracing::error!("tesselation for layer source {source_layer} at {coords} failed {e:?}");
+                        } else {
+                            tessellator_new.finish();
+                            context.symbol_layer_tesselation_finished(
+                                coords,
+                                tessellator.quad_buffer.into(),
+                                tessellator_new.quad_buffer.into(),
+                                tessellator.features,
+                                original_layer,
+                            )?;
+                        }
+                    }
+                    _ => {
+                        log::warn!("unhandled style layer type in {id}");
+                    }
+                }
+            } else {
+                log::warn!("layer source {source_layer} not found in vector tile");
+            }
         } else {
-            context.layer_tesselation_finished(
-                coords,
-                tessellator.buffer.into(),
-                tessellator.feature_indices,
-                cloned_layer,
-            )?;
+            log::error!("vector style layer {id} misses a required attribute");
         }
     }
 
-    // Missing
-
+    // Report missing layers
     let coords = &tile_request.coords;
-
     let available_layers: HashSet<_> = tile
         .layers
         .iter()
         .map(|layer| layer.name.clone())
         .collect::<HashSet<_>>();
 
-    for missing_layer in tile_request.layers.difference(&available_layers) {
-        context.layer_missing(coords, missing_layer)?;
-        tracing::info!("requested layer {missing_layer} at {coords} not found in tile");
+    for layer in tile_request.layers {
+        if let Some(source_layer) = layer.source_layer {
+            if !available_layers.contains(&source_layer) {
+                context.layer_missing(coords, &source_layer)?;
+                tracing::info!(
+                    "requested source layer {source_layer} at {coords} not found in tile"
+                );
+            }
+        }
     }
 
-    // Indexing
-
+    // Report index for layer
     let mut index = IndexProcessor::new();
 
     for layer in &mut tile.layers {
@@ -96,8 +141,7 @@ pub fn process_vector_tile<T: VectorTransferables, C: Context>(
 
     context.layer_indexing_finished(&tile_request.coords, index.get_geometries())?;
 
-    // End
-
+    // Report end
     tracing::info!("tile tessellated at {coords} finished");
     context.tile_finished(coords)?;
 
@@ -156,6 +200,21 @@ impl<T: VectorTransferables, C: Context> ProcessVectorContext<T, C> {
             .map_err(|e| ProcessVectorError::SendError(e))
     }
 
+    fn symbol_layer_tesselation_finished(
+        &mut self,
+        coords: &WorldTileCoords,
+        buffer: OverAlignedVertexBuffer<ShaderSymbolVertex, IndexDataType>,
+        new_buffer: OverAlignedVertexBuffer<ShaderSymbolVertexNew, IndexDataType>,
+        features: Vec<Feature>,
+        layer_data: tile::Layer,
+    ) -> Result<(), ProcessVectorError> {
+        self.context
+            .send_back(T::SymbolLayerTessellated::build_from(
+                *coords, buffer, new_buffer, features, layer_data,
+            ))
+            .map_err(|e| ProcessVectorError::SendError(e))
+    }
+
     fn layer_indexing_finished(
         &mut self,
         coords: &WorldTileCoords,
diff --git a/maplibre/src/vector/queue_system.rs b/maplibre/src/vector/queue_system.rs
index adfc5a308..070add986 100644
--- a/maplibre/src/vector/queue_system.rs
+++ b/maplibre/src/vector/queue_system.rs
@@ -7,11 +7,14 @@ use crate::{
         render_phase::{DrawState, LayerItem, RenderPhase, TileMaskItem},
         tile_view_pattern::WgpuTileViewPattern,
     },
-    tcs::tiles::Tile,
+    tcs::{
+        system::{SystemError, SystemResult},
+        tiles::Tile,
+    },
     vector::{render_commands::DrawVectorTiles, VectorBufferPool},
 };
 
-pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
+pub fn queue_system(MapContext { world, .. }: &mut MapContext) -> SystemResult {
     let Some((
         Initialized(tile_view_pattern),
         Initialized(buffer_pool),
@@ -24,7 +27,7 @@ pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
         &mut RenderPhase<LayerItem>,
     )>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     let buffer_pool_index = buffer_pool.index();
@@ -43,6 +46,7 @@ pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
 
             if let Some(layer_entries) = buffer_pool_index.get_layers(source_shape.coords()) {
                 for layer_entry in layer_entries {
+                    // continue;
                     // Draw tile
                     layer_item_phase.add(LayerItem {
                         draw_function: Box::new(DrawState::<LayerItem, DrawVectorTiles>::new()),
@@ -57,4 +61,6 @@ pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
             };
         });
     }
+
+    Ok(())
 }
diff --git a/maplibre/src/vector/request_system.rs b/maplibre/src/vector/request_system.rs
index 1c410fead..6bc8f959b 100644
--- a/maplibre/src/vector/request_system.rs
+++ b/maplibre/src/vector/request_system.rs
@@ -10,13 +10,14 @@ use crate::{
         source_type::{SourceType, TessellateSource},
     },
     kernel::Kernel,
-    render::tile_view_pattern::DEFAULT_TILE_SIZE,
-    style::layer::LayerPaint,
-    tcs::system::System,
+    render::{tile_view_pattern::DEFAULT_TILE_SIZE, view_state::ViewStatePadding},
+    sdf::SymbolLayersDataComponent,
+    style::layer::StyleLayer,
+    tcs::system::{System, SystemResult},
     vector::{
         process_vector::{process_vector_tile, ProcessVectorContext, VectorTileRequest},
         transferables::{LayerMissing, VectorTransferables},
-        VectorLayersDataComponent,
+        VectorLayerBucketComponent,
     },
 };
 
@@ -47,10 +48,12 @@ impl<E: Environment, T: VectorTransferables> System for RequestSystem<E, T> {
             world,
             ..
         }: &mut MapContext,
-    ) {
+    ) -> SystemResult {
         let _tiles = &mut world.tiles;
-        let view_region =
-            view_state.create_view_region(view_state.zoom().zoom_level(DEFAULT_TILE_SIZE));
+        let view_region = view_state.create_view_region(
+            view_state.zoom().zoom_level(DEFAULT_TILE_SIZE),
+            ViewStatePadding::Loose,
+        );
 
         if view_state.did_camera_change() || view_state.did_zoom_change() {
             if let Some(view_region) = &view_region {
@@ -64,7 +67,7 @@ impl<E: Environment, T: VectorTransferables> System for RequestSystem<E, T> {
                     // TODO: Make tesselation depend on style? So maybe we need to request even if it exists
                     if world
                         .tiles
-                        .query::<&VectorLayersDataComponent>(coords)
+                        .query::<&VectorLayerBucketComponent>(coords)
                         .is_some()
                     {
                         continue;
@@ -74,7 +77,8 @@ impl<E: Environment, T: VectorTransferables> System for RequestSystem<E, T> {
                         .tiles
                         .spawn_mut(coords)
                         .unwrap()
-                        .insert(VectorLayersDataComponent::default());
+                        .insert(VectorLayerBucketComponent::default())
+                        .insert(SymbolLayersDataComponent::default());
 
                     tracing::event!(tracing::Level::ERROR, %coords, "tile request started: {coords}");
                     log::info!("tile request started: {coords}");
@@ -98,8 +102,7 @@ impl<E: Environment, T: VectorTransferables> System for RequestSystem<E, T> {
                 }
             }
         }
-
-        view_state.update_references();
+        Ok(())
     }
 }
 
@@ -113,23 +116,11 @@ pub fn fetch_vector_apc<K: OffscreenKernel, T: VectorTransferables, C: Context +
             return Err(ProcedureError::IncompatibleInput);
         };
 
-        let fill_layers: HashSet<String> = style
-            .layers
-            .iter()
-            .filter_map(|layer| {
-                if matches!(layer.paint, Some(LayerPaint::Fill(_)))
-                    || matches!(layer.paint, Some(LayerPaint::Line(_)))
-                {
-                    layer.source_layer.clone()
-                } else {
-                    None
-                }
-            })
-            .collect();
+        let requested_layers: HashSet<StyleLayer> = style.layers.iter().cloned().collect();
 
         let client = kernel.source_client();
 
-        if !fill_layers.is_empty() {
+        if !style.layers.is_empty() {
             let context = context.clone();
             let source = SourceType::Tessellate(TessellateSource::default());
             match client.fetch(&coords, &source).await {
@@ -141,7 +132,7 @@ pub fn fetch_vector_apc<K: OffscreenKernel, T: VectorTransferables, C: Context +
                         &data,
                         VectorTileRequest {
                             coords,
-                            layers: fill_layers,
+                            layers: requested_layers,
                         },
                         &mut pipeline_context,
                     )
@@ -149,11 +140,11 @@ pub fn fetch_vector_apc<K: OffscreenKernel, T: VectorTransferables, C: Context +
                 }
                 Err(e) => {
                     log::error!("{e:?}");
-                    for to_load in &fill_layers {
+                    for to_load in &requested_layers {
                         context
                             .send_back(<T as VectorTransferables>::LayerMissing::build_from(
                                 coords,
-                                to_load.to_string(),
+                                to_load.id.clone(),
                             ))
                             .map_err(ProcedureError::Send)?;
                     }
diff --git a/maplibre/src/vector/resource/buffer_pool.rs b/maplibre/src/vector/resource/buffer_pool.rs
index 9a92b279a..777f5edb9 100644
--- a/maplibre/src/vector/resource/buffer_pool.rs
+++ b/maplibre/src/vector/resource/buffer_pool.rs
@@ -18,7 +18,7 @@ use crate::{
     },
     style::layer::StyleLayer,
     tcs::world::World,
-    tessellation::OverAlignedVertexBuffer,
+    vector::tessellation::OverAlignedVertexBuffer,
 };
 
 // TODO: Too low values can cause a back-and-forth between unloading and loading layers
diff --git a/maplibre/src/vector/resource_system.rs b/maplibre/src/vector/resource_system.rs
index efc4c579e..de8edc668 100644
--- a/maplibre/src/vector/resource_system.rs
+++ b/maplibre/src/vector/resource_system.rs
@@ -8,6 +8,7 @@ use crate::{
         shaders::Shader,
         RenderResources, Renderer,
     },
+    tcs::system::{SystemError, SystemResult},
     vector::{resource::BufferPool, VectorBufferPool, VectorPipeline},
 };
 
@@ -23,18 +24,18 @@ pub fn resource_system(
             },
         ..
     }: &mut MapContext,
-) {
+) -> SystemResult {
     let Some((buffer_pool, vector_pipeline)) = world.resources.query_mut::<(
         &mut Eventually<VectorBufferPool>,
         &mut Eventually<VectorPipeline>,
     )>() else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
     buffer_pool.initialize(|| BufferPool::from_device(device));
 
     vector_pipeline.initialize(|| {
-        let tile_shader = shaders::VectorTileShader {
+        let tile_shader = shaders::FillShader {
             format: surface.surface_format(),
         };
 
@@ -49,10 +50,13 @@ pub fn resource_system(
             false,
             surface.is_multisampling_supported(settings.msaa),
             false,
+            false,
         )
         .describe_render_pipeline()
         .initialize(device);
 
         VectorPipeline(pipeline)
     });
+
+    Ok(())
 }
diff --git a/maplibre/src/tessellation/zero_tessellator.rs b/maplibre/src/vector/tessellation.rs
similarity index 60%
rename from maplibre/src/tessellation/zero_tessellator.rs
rename to maplibre/src/vector/tessellation.rs
index 8502373f3..b79895a45 100644
--- a/maplibre/src/tessellation/zero_tessellator.rs
+++ b/maplibre/src/vector/tessellation.rs
@@ -1,25 +1,125 @@
-//! Tessellator implementation.
+//! Tessellation for lines and polygons is implemented here.
 
 use std::cell::RefCell;
 
+use bytemuck::Pod;
 use geozero::{FeatureProcessor, GeomProcessor, PropertyProcessor};
 use lyon::{
     geom,
-    lyon_tessellation::VertexBuffers,
     path::{path::Builder, Path},
     tessellation::{
         geometry_builder::MaxIndex, BuffersBuilder, FillOptions, FillRule, FillTessellator,
-        StrokeOptions, StrokeTessellator,
+        FillVertex, FillVertexConstructor, StrokeOptions, StrokeTessellator, StrokeVertex,
+        StrokeVertexConstructor, VertexBuffers,
     },
 };
 
-use crate::{
-    render::ShaderVertex,
-    tessellation::{VertexConstructor, DEFAULT_TOLERANCE},
-};
+use crate::render::ShaderVertex;
+
+const DEFAULT_TOLERANCE: f32 = 0.02;
+
+/// Vertex buffers index data type.
+pub type IndexDataType = u32; // Must match INDEX_FORMAT
 
 type GeoResult<T> = geozero::error::Result<T>;
 
+/// Constructor for Fill and Stroke vertices.
+pub struct VertexConstructor {}
+
+impl FillVertexConstructor<ShaderVertex> for VertexConstructor {
+    fn new_vertex(&mut self, vertex: FillVertex) -> ShaderVertex {
+        ShaderVertex::new(vertex.position().to_array(), [0.0, 0.0])
+    }
+}
+
+impl StrokeVertexConstructor<ShaderVertex> for VertexConstructor {
+    fn new_vertex(&mut self, vertex: StrokeVertex) -> ShaderVertex {
+        ShaderVertex::new(
+            vertex.position_on_path().to_array(),
+            vertex.normal().to_array(),
+        )
+    }
+}
+
+/// Vertex buffer which includes additional padding to fulfill the `wgpu::COPY_BUFFER_ALIGNMENT`.
+#[derive(Clone)]
+pub struct OverAlignedVertexBuffer<V, I> {
+    pub buffer: VertexBuffers<V, I>,
+    pub usable_indices: u32,
+}
+
+impl<V, I> OverAlignedVertexBuffer<V, I> {
+    pub fn empty() -> Self {
+        Self {
+            buffer: VertexBuffers::with_capacity(0, 0),
+            usable_indices: 0,
+        }
+    }
+
+    pub fn from_iters<IV, II>(vertices: IV, indices: II, usable_indices: u32) -> Self
+    where
+        IV: IntoIterator<Item = V>,
+        II: IntoIterator<Item = I>,
+        IV::IntoIter: ExactSizeIterator,
+        II::IntoIter: ExactSizeIterator,
+    {
+        let vertices = vertices.into_iter();
+        let indices = indices.into_iter();
+        let mut buffers = VertexBuffers::with_capacity(vertices.len(), indices.len());
+        buffers.vertices.extend(vertices);
+        buffers.indices.extend(indices);
+        Self {
+            buffer: buffers,
+            usable_indices,
+        }
+    }
+}
+
+impl<V: Pod, I: Pod> From<VertexBuffers<V, I>> for OverAlignedVertexBuffer<V, I> {
+    fn from(mut buffer: VertexBuffers<V, I>) -> Self {
+        let usable_indices = buffer.indices.len() as u32;
+        buffer.align_vertices();
+        buffer.align_indices();
+        Self {
+            buffer,
+            usable_indices,
+        }
+    }
+}
+
+trait Align<V: Pod, I: Pod> {
+    fn align_vertices(&mut self);
+    fn align_indices(&mut self);
+}
+
+impl<V: Pod, I: Pod> Align<V, I> for VertexBuffers<V, I> {
+    fn align_vertices(&mut self) {
+        let align = wgpu::COPY_BUFFER_ALIGNMENT;
+        let stride = std::mem::size_of::<V>() as wgpu::BufferAddress;
+        let unpadded_bytes = self.vertices.len() as wgpu::BufferAddress * stride;
+        let padding_bytes = (align - unpadded_bytes % align) % align;
+
+        if padding_bytes != 0 {
+            panic!(
+                "vertices are always aligned to wgpu::COPY_BUFFER_ALIGNMENT \
+                    because GpuVertexUniform is aligned"
+            )
+        }
+    }
+
+    fn align_indices(&mut self) {
+        let align = wgpu::COPY_BUFFER_ALIGNMENT;
+        let stride = std::mem::size_of::<I>() as wgpu::BufferAddress;
+        let unpadded_bytes = self.indices.len() as wgpu::BufferAddress * stride;
+        let padding_bytes = (align - unpadded_bytes % align) % align;
+        let overpad = (padding_bytes + stride - 1) / stride; // Divide by stride but round up
+
+        for _ in 0..overpad {
+            self.indices.push(I::zeroed());
+        }
+    }
+}
+
 /// Build tessellations with vectors.
 pub struct ZeroTessellator<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> {
     path_builder: RefCell<Builder>,
@@ -48,6 +148,8 @@ impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> Default
 }
 
 impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> ZeroTessellator<I> {
+    /// Stores current indices to the output. That way we know which vertices correspond to which
+    /// feature in the output.
     fn update_feature_indices(&mut self) {
         let next_index = self.buffer.indices.len();
         let indices = (next_index - self.current_index) as u32;
diff --git a/maplibre/src/vector/transferables.rs b/maplibre/src/vector/transferables.rs
index 711845ffa..3f6fc513f 100644
--- a/maplibre/src/vector/transferables.rs
+++ b/maplibre/src/vector/transferables.rs
@@ -8,9 +8,15 @@ use crate::{
         apc::{IntoMessage, Message, MessageTag},
         geometry_index::TileIndex,
     },
-    render::ShaderVertex,
-    tessellation::{IndexDataType, OverAlignedVertexBuffer},
-    vector::{AvailableVectorLayerData, MissingVectorLayerData},
+    render::{
+        shaders::{ShaderSymbolVertex, ShaderSymbolVertexNew},
+        ShaderVertex,
+    },
+    sdf::{Feature, SymbolLayerData},
+    vector::{
+        tessellation::{IndexDataType, OverAlignedVertexBuffer},
+        AvailableVectorLayerBucket, MissingVectorLayerBucket,
+    },
 };
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
@@ -18,7 +24,8 @@ pub enum VectorMessageTag {
     TileTessellated = 1,
     LayerMissing = 2,
     LayerTessellated = 3,
-    LayerIndexed = 4,
+    SymbolLayerTessellated = 4,
+    LayerIndexed = 10,
 }
 
 impl MessageTag for VectorMessageTag {
@@ -48,7 +55,7 @@ pub trait LayerMissing: IntoMessage + Debug + Send {
 
     fn layer_name(&self) -> &str;
 
-    fn to_layer(self) -> MissingVectorLayerData;
+    fn to_bucket(self) -> MissingVectorLayerBucket;
 }
 
 pub trait LayerTessellated: IntoMessage + Debug + Send {
@@ -67,7 +74,27 @@ pub trait LayerTessellated: IntoMessage + Debug + Send {
 
     fn is_empty(&self) -> bool;
 
-    fn to_layer(self) -> AvailableVectorLayerData;
+    fn to_bucket(self) -> AvailableVectorLayerBucket;
+}
+
+pub trait SymbolLayerTessellated: IntoMessage + Debug + Send {
+    fn message_tag() -> &'static dyn MessageTag;
+
+    fn build_from(
+        coords: WorldTileCoords,
+        buffer: OverAlignedVertexBuffer<ShaderSymbolVertex, IndexDataType>,
+        new_buffer: OverAlignedVertexBuffer<ShaderSymbolVertexNew, IndexDataType>,
+        features: Vec<Feature>,
+        layer_data: Layer,
+    ) -> Self
+    where
+        Self: Sized;
+
+    fn coords(&self) -> WorldTileCoords;
+
+    fn is_empty(&self) -> bool;
+
+    fn to_bucket(self) -> SymbolLayerData;
 }
 
 pub trait LayerIndexed: IntoMessage + Debug + Send {
@@ -146,8 +173,8 @@ impl LayerMissing for DefaultLayerMissing {
         &self.layer_name
     }
 
-    fn to_layer(self) -> MissingVectorLayerData {
-        MissingVectorLayerData {
+    fn to_bucket(self) -> MissingVectorLayerBucket {
+        MissingVectorLayerBucket {
             coords: self.coords,
             source_layer: self.layer_name,
         }
@@ -155,7 +182,7 @@ impl LayerMissing for DefaultLayerMissing {
 }
 
 #[derive(Clone)]
-pub struct DefaultLayerTesselated {
+pub struct DefaultLayerTessellated {
     pub coords: WorldTileCoords,
     pub buffer: OverAlignedVertexBuffer<ShaderVertex, IndexDataType>,
     /// Holds for each feature the count of indices.
@@ -163,19 +190,19 @@ pub struct DefaultLayerTesselated {
     pub layer_data: Layer, // FIXME (perf): Introduce a better structure for this
 }
 
-impl Debug for DefaultLayerTesselated {
+impl Debug for DefaultLayerTessellated {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "DefaultLayerTesselated({})", self.coords)
     }
 }
 
-impl IntoMessage for DefaultLayerTesselated {
+impl IntoMessage for DefaultLayerTessellated {
     fn into(self) -> Message {
         Message::new(Self::message_tag(), Box::new(self))
     }
 }
 
-impl LayerTessellated for DefaultLayerTesselated {
+impl LayerTessellated for DefaultLayerTessellated {
     fn message_tag() -> &'static dyn MessageTag {
         &VectorMessageTag::LayerTessellated
     }
@@ -202,8 +229,8 @@ impl LayerTessellated for DefaultLayerTesselated {
         self.buffer.usable_indices == 0
     }
 
-    fn to_layer(self) -> AvailableVectorLayerData {
-        AvailableVectorLayerData {
+    fn to_bucket(self) -> AvailableVectorLayerBucket {
+        AvailableVectorLayerBucket {
             coords: self.coords,
             source_layer: self.layer_data.name,
             buffer: self.buffer,
@@ -212,6 +239,66 @@ impl LayerTessellated for DefaultLayerTesselated {
     }
 }
 
+pub struct DefaultSymbolLayerTessellated {
+    pub coords: WorldTileCoords,
+    pub buffer: OverAlignedVertexBuffer<ShaderSymbolVertex, IndexDataType>,
+    pub new_buffer: OverAlignedVertexBuffer<ShaderSymbolVertexNew, IndexDataType>,
+    pub features: Vec<Feature>,
+    pub layer_data: Layer, // FIXME (perf): Introduce a better structure for this
+}
+
+impl Debug for crate::vector::transferables::DefaultSymbolLayerTessellated {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "DefaultSymbolLayerTessellated({})", self.coords)
+    }
+}
+
+impl IntoMessage for crate::vector::transferables::DefaultSymbolLayerTessellated {
+    fn into(self) -> Message {
+        Message::new(Self::message_tag(), Box::new(self))
+    }
+}
+
+impl SymbolLayerTessellated for crate::vector::transferables::DefaultSymbolLayerTessellated {
+    fn message_tag() -> &'static dyn MessageTag {
+        &VectorMessageTag::SymbolLayerTessellated
+    }
+
+    fn build_from(
+        coords: WorldTileCoords,
+        buffer: OverAlignedVertexBuffer<ShaderSymbolVertex, IndexDataType>,
+        new_buffer: OverAlignedVertexBuffer<ShaderSymbolVertexNew, IndexDataType>,
+        features: Vec<Feature>,
+        layer_data: Layer,
+    ) -> Self {
+        Self {
+            coords,
+            buffer,
+            new_buffer,
+            features,
+            layer_data,
+        }
+    }
+
+    fn coords(&self) -> WorldTileCoords {
+        self.coords
+    }
+
+    fn is_empty(&self) -> bool {
+        self.buffer.usable_indices == 0
+    }
+
+    fn to_bucket(self) -> SymbolLayerData {
+        SymbolLayerData {
+            coords: self.coords,
+            source_layer: self.layer_data.name,
+            buffer: self.buffer,
+            new_buffer: self.new_buffer,
+            features: self.features,
+        }
+    }
+}
+
 pub struct DefaultLayerIndexed {
     coords: WorldTileCoords,
     index: TileIndex,
@@ -251,6 +338,7 @@ pub trait VectorTransferables: Copy + Clone + 'static {
     type TileTessellated: TileTessellated;
     type LayerMissing: LayerMissing;
     type LayerTessellated: LayerTessellated;
+    type SymbolLayerTessellated: SymbolLayerTessellated;
     type LayerIndexed: LayerIndexed;
 }
 
@@ -260,6 +348,7 @@ pub struct DefaultVectorTransferables;
 impl VectorTransferables for DefaultVectorTransferables {
     type TileTessellated = DefaultTileTessellated;
     type LayerMissing = DefaultLayerMissing;
-    type LayerTessellated = DefaultLayerTesselated;
+    type LayerTessellated = DefaultLayerTessellated;
+    type SymbolLayerTessellated = DefaultSymbolLayerTessellated;
     type LayerIndexed = DefaultLayerIndexed;
 }
diff --git a/maplibre/src/vector/upload_system.rs b/maplibre/src/vector/upload_system.rs
index 3ba3c503b..df782d818 100644
--- a/maplibre/src/vector/upload_system.rs
+++ b/maplibre/src/vector/upload_system.rs
@@ -7,14 +7,18 @@ use crate::{
     coords::ViewRegion,
     render::{
         eventually::{Eventually, Eventually::Initialized},
-        shaders::{ShaderFeatureStyle, ShaderLayerMetadata, Vec4f32},
+        shaders::{FillShaderFeatureMetadata, ShaderLayerMetadata, Vec4f32},
         tile_view_pattern::DEFAULT_TILE_SIZE,
+        view_state::ViewStatePadding,
         Renderer,
     },
     style::Style,
-    tcs::tiles::Tiles,
+    tcs::{
+        system::{SystemError, SystemResult},
+        tiles::Tiles,
+    },
     vector::{
-        AvailableVectorLayerData, VectorBufferPool, VectorLayerData, VectorLayersDataComponent,
+        AvailableVectorLayerBucket, VectorBufferPool, VectorLayerBucket, VectorLayerBucketComponent,
     },
 };
 
@@ -26,19 +30,21 @@ pub fn upload_system(
         renderer: Renderer { device, queue, .. },
         ..
     }: &mut MapContext,
-) {
+) -> SystemResult {
     let Some(Initialized(buffer_pool)) = world
         .resources
         .query_mut::<&mut Eventually<VectorBufferPool>>()
     else {
-        return;
+        return Err(SystemError::Dependencies);
     };
 
-    let view_region =
-        view_state.create_view_region(view_state.zoom().zoom_level(DEFAULT_TILE_SIZE));
+    let view_region = view_state.create_view_region(
+        view_state.zoom().zoom_level(DEFAULT_TILE_SIZE),
+        ViewStatePadding::Loose,
+    );
 
     if let Some(view_region) = &view_region {
-        upload_tesselated_layer(
+        upload_tessellated_layer(
             buffer_pool,
             device,
             queue,
@@ -46,82 +52,12 @@ pub fn upload_system(
             style,
             view_region,
         );
-        // self.update_metadata(state, tile_repository, queue);
     }
-}
-
-/* FIXME tcs fn update_metadata(
-    buffer_pool: &VectorBufferPool,
-    tiles: &Tiles,
-    queue: &wgpu::Queue,
-) {
-    let animated_one = 0.5
-        * (1.0
-            + ((std::time::SystemTime::now()
-                .duration_since(std::time::SystemTime::UNIX_EPOCH)
-                .unwrap()
-                .as_secs_f64())
-            .sin()));
-
-    for entries in buffer_pool.index().iter() {
-        for entry in entries {
-            let world_coords = entry.coords;
-
-            let source_layer = entry.style_layer.source_layer.as_ref().unwrap();
-
-            let Some(stored_layer) =
-                tile_repository
-                    .iter_layers_at(&world_coords)
-                    .and_then(|mut layers| {
-                        layers.find(|layer| source_layer.as_str() == layer.layer_name())
-                    })  else { continue; };
-
-            let color: Option<Vec4f32> = entry
-                .style_layer
-                .paint
-                .as_ref()
-                .and_then(|paint| paint.get_color())
-                .map(|mut color| {
-                    color.color.b = animated_one as f32;
-                    color.into()
-                });
-
-            match stored_layer {
-                StoredLayer::UnavailableLayer { .. } => {}
-                StoredLayer::TessellatedLayer {
-                    feature_indices, ..
-                } => {
-                    /* let feature_metadata = layer_data
-                    .features()
-                    .iter()
-                    .enumerate()
-                    .flat_map(|(i, _feature)| {
-                        iter::repeat(ShaderFeatureStyle {
-                            color: color.unwrap(),
-                        })
-                        .take(feature_indices[i] as usize)
-                    })
-                    .collect::<Vec<_>>();*/
 
-                    let feature_metadata = (0..feature_indices.len())
-                        .flat_map(|i| {
-                            iter::repeat(ShaderFeatureStyle {
-                                color: color.unwrap(),
-                            })
-                            .take(feature_indices[i] as usize)
-                        })
-                        .collect::<Vec<_>>();
-
-                    buffer_pool.update_feature_metadata(queue, entry, &feature_metadata);
-                }
-
-                StoredLayer::RasterLayer { .. } => {}
-            }
-        }
-    }
-}*/
+    Ok(())
+}
 
-fn upload_tesselated_layer(
+fn upload_tessellated_layer(
     buffer_pool: &mut VectorBufferPool,
     _device: &wgpu::Device,
     queue: &wgpu::Queue,
@@ -131,7 +67,7 @@ fn upload_tesselated_layer(
 ) {
     // Upload all tessellated layers which are in view
     for coords in view_region.iter() {
-        let Some(vector_layers) = tiles.query_mut::<&VectorLayersDataComponent>(coords) else {
+        let Some(vector_layers) = tiles.query_mut::<&VectorLayerBucketComponent>(coords) else {
             continue;
         };
 
@@ -143,16 +79,23 @@ fn upload_tesselated_layer(
             .layers
             .iter()
             .flat_map(|data| match data {
-                VectorLayerData::Available(data) => Some(data),
-                VectorLayerData::Missing(_) => None,
+                VectorLayerBucket::AvailableLayer(data) => Some(data),
+                VectorLayerBucket::Missing(_) => None,
             })
             .filter(|data| !loaded_layers.contains(data.source_layer.as_str()))
             .collect::<Vec<_>>();
 
         for style_layer in &style.layers {
-            let source_layer = style_layer.source_layer.as_ref().unwrap(); // TODO: Unwrap
+            let layer_id = &style_layer.id;
+            let source_layer = match style_layer.source_layer.as_ref() {
+                Some(layer) => layer,
+                None => {
+                    log::trace!("style layer {layer_id} does not have a source layer");
+                    continue;
+                }
+            };
 
-            let Some(AvailableVectorLayerData {
+            let Some(AvailableVectorLayerBucket {
                 coords,
                 feature_indices,
                 buffer,
@@ -170,15 +113,17 @@ fn upload_tesselated_layer(
                 .and_then(|paint| paint.get_color())
                 .map(|color| color.into());
 
-            let feature_metadata = (0..feature_indices.len()) // FIXME: Iterate over actual features
-                .enumerate()
-                .flat_map(|(i, _feature)| {
-                    iter::repeat(ShaderFeatureStyle {
-                        color: color.unwrap(),
-                    })
-                    .take(feature_indices[i] as usize)
-                })
-                .collect::<Vec<_>>();
+            // Assign every feature in the layer the color from the style
+            let feature_metadata = iter::repeat(FillShaderFeatureMetadata {
+                color: color.unwrap(),
+            })
+            .take(feature_indices.iter().sum::<u32>() as usize)
+            .collect::<Vec<_>>();
+
+            // FIXME avoid uploading empty indices
+            if buffer.buffer.indices.is_empty() {
+                continue;
+            }
 
             log::debug!("Allocating geometry at {coords}");
             buffer_pool.allocate_layer_geometry(
@@ -186,7 +131,9 @@ fn upload_tesselated_layer(
                 *coords,
                 style_layer.clone(),
                 buffer,
-                ShaderLayerMetadata::new(style_layer.index as f32),
+                ShaderLayerMetadata {
+                    z_index: style_layer.index as f32,
+                },
                 &feature_metadata,
             );
         }
diff --git a/shell.nix b/shell.nix
index cfcefae2e..08f6110ae 100644
--- a/shell.nix
+++ b/shell.nix
@@ -1,4 +1,4 @@
-# This nix-shell only supports macOS right now. Soon I will also add support for Linux
+# This nix-shell supports macOS and Linux.
 # The repository supports direnv (https://direnv.net/). If your IDE supports direnv,
 # then you do not need to care about dependencies.
 
@@ -10,7 +10,7 @@ with pkgs;
 let
   unstable = import
     (builtins.fetchTarball {
-      url = "https://github.com/NixOS/nixpkgs/archive/075dce259f6ced5cee1226dd76474d0674b54e64.tar.gz";
+      url = "https://github.com/NixOS/nixpkgs/archive/cb9a96f23c491c081b38eab96d22fa958043c9fa.tar.gz"; # Ger from here: https://github.com/NixOS/nixpkgs/tree/nixos-unstable
     })
     { };
 in
@@ -31,12 +31,15 @@ in
       hash = "sha256-1VwY8vQy7soKEgbki4LD+v259751kKxSxmo/gqE6yV0=";
       cargoHash = "sha256-aACJ+lYNEU8FFBs158G1/JG8sc6Rq080PeKCMnwdpH0=";
     })
-    unstable.tracy
+    pkgs.cargo-criterion
     unstable.nixpkgs-fmt # To format this file: nixpkgs-fmt *.nix
     # System dependencies
     unstable.flatbuffers
     unstable.protobuf
 
+    unstable.tracy-x11
+    unstable.renderdoc
+
     pkgs.jdk17
 
     unstable.sqlite
@@ -50,10 +53,12 @@ in
     unstable.wayland
   ];
   shellHook = ''
-    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${ pkgs.lib.makeLibraryPath [ unstable.libxkbcommon ] }";
-    # Vulkan
-    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${ pkgs.lib.makeLibraryPath [ pkgs.vulkan-loader ] }";
-    # EGL
-    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${ pkgs.lib.makeLibraryPath [ pkgs.libglvnd ] }";
+    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${ pkgs.lib.makeLibraryPath [
+        unstable.libxkbcommon
+        # Vulkan
+        pkgs.vulkan-loader
+         # EGL
+        pkgs.libglvnd
+    ] }";
   '';
 }
diff --git a/web/flatbuffer/symbol_layer_tessellated.fbs b/web/flatbuffer/symbol_layer_tessellated.fbs
new file mode 100644
index 000000000..3d93b06f6
--- /dev/null
+++ b/web/flatbuffer/symbol_layer_tessellated.fbs
@@ -0,0 +1,21 @@
+include "basic.fbs";
+
+struct FlatSymbolVertex {
+    position: [float:3];
+    text_anchor: [float:3];
+    tex_coords: [float:2];
+    color: [ubyte:4];
+    is_glyph: uint;
+}
+
+table FlatSymbolLayerTessellated {
+    coords: FlatWorldTileCoords;
+    layer_name: string;
+    vertices: [FlatSymbolVertex];
+    indices: [uint];
+    usable_indices: uint;
+    // Holds for each feature the count of indices.
+    feature_indices: [uint];
+}
+
+root_type FlatSymbolLayerTessellated;
diff --git a/web/src/lib.rs b/web/src/lib.rs
index 040c34f10..a1f644cb4 100644
--- a/web/src/lib.rs
+++ b/web/src/lib.rs
@@ -131,6 +131,7 @@ pub async fn run_maplibre(new_worker: js_sys::Function) -> Result<(), JSError> {
         vec![
             Box::<maplibre::render::RenderPlugin>::default(),
             Box::<maplibre::vector::VectorPlugin<platform::UsedVectorTransferables>>::default(),
+            Box::new(maplibre::sdf::SdfPlugin::<platform::UsedVectorTransferables>::default()),
             // Box::new(RasterPlugin::<platform::UsedRasterTransferables>::default()),
             #[cfg(debug_assertions)]
             Box::<maplibre::debug::DebugPlugin>::default(),
diff --git a/web/src/platform/singlethreaded/apc.rs b/web/src/platform/singlethreaded/apc.rs
index 01e0b734e..038d43791 100644
--- a/web/src/platform/singlethreaded/apc.rs
+++ b/web/src/platform/singlethreaded/apc.rs
@@ -43,6 +43,7 @@ pub enum WebMessageTag {
     LayerIndexed = 4,
     LayerRaster = 5,
     LayerRasterMissing = 6,
+    SymbolLayerTessellated = 7,
 }
 
 impl WebMessageTag {
@@ -54,6 +55,7 @@ impl WebMessageTag {
             WebMessageTag::TileTessellated => &WebMessageTag::TileTessellated,
             WebMessageTag::LayerTessellated => &WebMessageTag::LayerTessellated,
             WebMessageTag::LayerRasterMissing => &WebMessageTag::LayerRasterMissing,
+            WebMessageTag::SymbolLayerTessellated => &WebMessageTag::SymbolLayerTessellated,
         }
     }
 
@@ -67,6 +69,9 @@ impl WebMessageTag {
             x if x == WebMessageTag::LayerRasterMissing as u32 => {
                 Ok(WebMessageTag::LayerRasterMissing)
             }
+            x if x == WebMessageTag::SymbolLayerTessellated as u32 => {
+                Ok(WebMessageTag::SymbolLayerTessellated)
+            }
             _ => Err(MessageTagDeserializeError),
         }
     }
@@ -96,6 +101,8 @@ impl Context for PassingContext {
             &WebMessageTag::LayerMissing
         } else if WebMessageTag::LayerIndexed.dyn_clone().as_ref() == message.tag() {
             &WebMessageTag::LayerIndexed
+        } else if WebMessageTag::SymbolLayerTessellated.dyn_clone().as_ref() == message.tag() {
+            &WebMessageTag::SymbolLayerTessellated
         } else {
             unreachable!()
         };
diff --git a/web/src/platform/singlethreaded/transferables.rs b/web/src/platform/singlethreaded/transferables.rs
index 383fe7fb3..9b4341da5 100644
--- a/web/src/platform/singlethreaded/transferables.rs
+++ b/web/src/platform/singlethreaded/transferables.rs
@@ -14,11 +14,15 @@ use maplibre::{
         AvailableRasterLayerData, LayerRaster, LayerRasterMissing, MissingRasterLayerData,
         RasterTransferables,
     },
-    render::ShaderVertex,
+    render::{
+        shaders::{ShaderSymbolVertex, ShaderSymbolVertexNew},
+        ShaderVertex,
+    },
+    sdf::{Feature, SymbolLayerData},
     tile::Layer,
     vector::{
-        AvailableVectorLayerData, LayerIndexed, LayerMissing, LayerTessellated,
-        MissingVectorLayerData, TileTessellated, VectorTransferables,
+        AvailableVectorLayerBucket, LayerIndexed, LayerMissing, LayerTessellated,
+        MissingVectorLayerBucket, SymbolLayerTessellated, TileTessellated, VectorTransferables,
     },
 };
 
@@ -26,7 +30,8 @@ use crate::platform::singlethreaded::{
     apc::WebMessageTag,
     transferables::{
         basic_generated::*, layer_indexed_generated::*, layer_missing_generated::*,
-        layer_raster_generated::*, layer_tessellated_generated::*, tile_tessellated_generated::*,
+        layer_raster_generated::*, layer_tessellated_generated::*,
+        symbol_layer_tessellated_generated::*, tile_tessellated_generated::*,
     },
 };
 
@@ -68,6 +73,14 @@ pub mod layer_raster_generated {
     include!(concat!(env!("OUT_DIR"), "/layer_raster_generated.rs"));
 }
 
+pub mod symbol_layer_tessellated_generated {
+    #![allow(unused, unused_imports, clippy::all)]
+    include!(concat!(
+        env!("OUT_DIR"),
+        "/symbol_layer_tessellated_generated.rs"
+    ));
+}
+
 pub struct FlatBufferTransferable {
     tag: WebMessageTag,
     data: Vec<u8>,
@@ -157,8 +170,8 @@ impl LayerMissing for FlatBufferTransferable {
         data.layer_name().expect("property must be set")
     }
 
-    fn to_layer(self) -> MissingVectorLayerData {
-        MissingVectorLayerData {
+    fn to_bucket(self) -> MissingVectorLayerBucket {
+        MissingVectorLayerBucket {
             source_layer: self.layer_name().to_owned(),
             coords: LayerMissing::coords(&self),
         }
@@ -235,7 +248,7 @@ impl LayerTessellated for FlatBufferTransferable {
         data.usable_indices() == 0
     }
 
-    fn to_layer(self) -> AvailableVectorLayerData {
+    fn to_bucket(self) -> AvailableVectorLayerBucket {
         let data = root_as_flat_layer_tessellated(&self.data[self.start..]).unwrap();
         let vertices = data
             .vertices()
@@ -246,7 +259,7 @@ impl LayerTessellated for FlatBufferTransferable {
         let indices = data.indices().unwrap();
         let feature_indices: Vec<u32> = data.feature_indices().unwrap().iter().collect();
         let usable_indices = data.usable_indices();
-        AvailableVectorLayerData {
+        AvailableVectorLayerBucket {
             coords: LayerTessellated::coords(&self),
             source_layer: data.layer_name().unwrap().to_owned(),
             buffer: OverAlignedVertexBuffer::from_iters(vertices, indices, usable_indices),
@@ -381,6 +394,100 @@ impl LayerRasterMissing for FlatBufferTransferable {
     }
 }
 
+impl SymbolLayerTessellated for FlatBufferTransferable {
+    fn message_tag() -> &'static dyn MessageTag {
+        &WebMessageTag::SymbolLayerTessellated
+    }
+
+    fn build_from(
+        coords: WorldTileCoords,
+        buffer: OverAlignedVertexBuffer<ShaderSymbolVertex, IndexDataType>,
+        new_buffer: OverAlignedVertexBuffer<ShaderSymbolVertexNew, IndexDataType>,
+        features: Vec<Feature>,
+        layer_data: Layer,
+    ) -> Self {
+        let mut inner_builder = FlatBufferBuilder::with_capacity(1024);
+
+        let vertices = inner_builder.create_vector(
+            &buffer
+                .buffer
+                .vertices
+                .iter()
+                .map(|vertex| {
+                    FlatSymbolVertex::new(
+                        &vertex.position,
+                        &vertex.text_anchor,
+                        &vertex.tex_coords,
+                        &vertex.color,
+                        vertex.is_glyph,
+                    )
+                })
+                .collect::<Vec<_>>(),
+        );
+        let indices = inner_builder.create_vector(&buffer.buffer.indices);
+        // FIXME symbol let feature_indices = inner_builder.create_vector(&feature_indices);
+        let layer_name = inner_builder.create_string(&layer_data.name);
+
+        let mut builder = FlatSymbolLayerTessellatedBuilder::new(&mut inner_builder);
+
+        builder.add_coords(&FlatWorldTileCoords::new(
+            coords.x,
+            coords.y,
+            coords.z.into(),
+        ));
+        builder.add_layer_name(layer_name);
+        builder.add_vertices(vertices);
+        builder.add_indices(indices);
+        // FIXME symbol builder.add_feature_indices(feature_indices);
+        builder.add_usable_indices(buffer.usable_indices);
+        let root = builder.finish();
+
+        inner_builder.finish(root, None);
+        let (data, start) = inner_builder.collapse();
+        FlatBufferTransferable {
+            tag: WebMessageTag::SymbolLayerTessellated,
+            data,
+            start,
+        }
+    }
+
+    fn coords(&self) -> WorldTileCoords {
+        let data = root_as_flat_symbol_layer_tessellated(&self.data[self.start..]).unwrap();
+        data.coords().unwrap().into()
+    }
+
+    fn is_empty(&self) -> bool {
+        let data = root_as_flat_symbol_layer_tessellated(&self.data[self.start..]).unwrap();
+        data.usable_indices() == 0
+    }
+
+    fn to_bucket(self) -> SymbolLayerData {
+        let data = root_as_flat_symbol_layer_tessellated(&self.data[self.start..]).unwrap();
+        let vertices = data
+            .vertices()
+            .unwrap()
+            .iter()
+            .map(|vertex| ShaderSymbolVertex {
+                position: vertex.position().into(),
+                text_anchor: vertex.text_anchor().into(),
+                tex_coords: vertex.tex_coords().into(),
+                color: vertex.color().into(),
+                is_glyph: vertex.is_glyph(),
+            });
+
+        let indices = data.indices().unwrap();
+        let feature_indices: Vec<u32> = data.feature_indices().unwrap().iter().collect();
+        let usable_indices = data.usable_indices();
+        SymbolLayerData {
+            coords: LayerTessellated::coords(&self),
+            source_layer: data.layer_name().unwrap().to_owned(),
+            buffer: OverAlignedVertexBuffer::from_iters(vertices, indices, usable_indices),
+            new_buffer: OverAlignedVertexBuffer::empty(), // FIXME symbol
+            features: vec![], // previously: feature_indices FIXME symbol
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct FlatTransferables;
 
@@ -388,6 +495,7 @@ impl VectorTransferables for FlatTransferables {
     type TileTessellated = FlatBufferTransferable;
     type LayerMissing = FlatBufferTransferable;
     type LayerTessellated = FlatBufferTransferable;
+    type SymbolLayerTessellated = FlatBufferTransferable;
     type LayerIndexed = FlatBufferTransferable;
 }