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_demo__debug_.xml b/.idea/runConfigurations/Run_demo__debug_.xml
index 008d47370..ef52bbb6a 100644
--- a/.idea/runConfigurations/Run_demo__debug_.xml
+++ b/.idea/runConfigurations/Run_demo__debug_.xml
@@ -4,6 +4,7 @@
     <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 4b9829dbe..c179678e0 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-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 3a3eadd83..de461ee1f 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/lib.rs b/maplibre/src/lib.rs
index 44cb089a8..186a7b6ea 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,5 @@ pub mod tcs;
 pub mod debug;
 pub mod raster;
 pub mod vector;
+
+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 cf2a24a40..5c2cb70b5 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..1c7615d93 100644
--- a/maplibre/src/render/shaders/mod.rs
+++ b/maplibre/src/render/shaders/mod.rs
@@ -92,14 +92,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 +170,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 +258,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 +312,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 +375,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 +388,157 @@ 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 {
+    // 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,
+}
+
+
+pub struct SymbolShader {
+    pub format: wgpu::TextureFormat,
+}
+
+impl Shader for SymbolShader {
+    fn describe_vertex(&self) -> VertexState {
+        VertexState {
+            source: include_str!("sdf.vertex.wgsl"),
+            entry_point: "main",
+            buffers: vec![
+                // vertex data
+                VertexBufferLayout {
+                    array_stride: std::mem::size_of::<ShaderSymbolVertex>() as u64,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    attributes: vec![
+                        // position
+                        wgpu::VertexAttribute {
+                            offset: 0,
+                            format: wgpu::VertexFormat::Float32x3,
+                            shader_location: 0,
+                        },
+                        // text_anchor
+                        wgpu::VertexAttribute {
+                            offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
+                            shader_location: 1,
+                            format: wgpu::VertexFormat::Float32x3,
+                        },
+                        // tex coords
+                        wgpu::VertexAttribute {
+                            offset: (std::mem::size_of::<[f32; 3]>() * 2) as wgpu::BufferAddress,
+                            shader_location: 11,
+                            format: wgpu::VertexFormat::Float32x2,
+                        },
+                    ],
+                },
+                // 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.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..8de6c72a2
--- /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 fontScale = 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 / (fontScale * 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) / (fontScale * gamma_scale);
+        buff = (6.0 - halo_width / fontScale) / 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/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/bidi.rs b/maplibre/src/sdf/bidi.rs
new file mode 100644
index 000000000..7e6f0e02b
--- /dev/null
+++ b/maplibre/src/sdf/bidi.rs
@@ -0,0 +1,63 @@
+use std::collections::BTreeSet;
+
+use widestring::U16String;
+
+pub type Char16 = u16; // was char16_t
+
+pub fn applyArabicShaping(str: &U16String) -> U16String {
+    // todo!();
+    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
+pub type StyledText = (U16String, Vec<u8>);
+
+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
+    pub fn processText(
+        &self,
+        input: &U16String,
+        mut lineBreakPoints: BTreeSet<usize>, // TODO: Make sure this is no output
+    ) -> Vec<U16String> {
+        lineBreakPoints.insert(input.len());
+
+        let mut transformedLines = Vec::new();
+        let mut start = 0;
+        for lineBreakPoint in lineBreakPoints {
+            transformedLines.push(U16String::from(&input[start..lineBreakPoint])); // TODO verify if this is correct
+            start = lineBreakPoint;
+        }
+
+        return transformedLines;
+    }
+
+    /// Same as processText but preserves per-code-point formatting information
+    pub fn processStyledText(
+        &self,
+        input: &StyledText,
+        mut lineBreakPoints: BTreeSet<usize>, // TODO: Make sure this is no output
+    ) -> Vec<StyledText> {
+        lineBreakPoints.insert(input.0.len());
+
+        let mut transformedLines = Vec::new();
+        let mut start = 0;
+        for lineBreakPoint in lineBreakPoints {
+            if (lineBreakPoint <= input.1.len()) {
+                transformedLines.push((
+                    U16String::from(&input.0[start..lineBreakPoint]),
+                    Vec::from(&input.1[start..lineBreakPoint]),
+                )); // TODO verify if this is correct
+                start = lineBreakPoint;
+            }
+        }
+
+        return transformedLines;
+    }
+}
diff --git a/maplibre/src/sdf/buckets/mod.rs b/maplibre/src/sdf/buckets/mod.rs
new file mode 100644
index 000000000..a7c501bbf
--- /dev/null
+++ b/maplibre/src/sdf/buckets/mod.rs
@@ -0,0 +1 @@
+pub mod symbol_bucket;
diff --git a/maplibre/src/sdf/buckets/symbol_bucket.rs b/maplibre/src/sdf/buckets/symbol_bucket.rs
new file mode 100644
index 000000000..6573200b6
--- /dev/null
+++ b/maplibre/src/sdf/buckets/symbol_bucket.rs
@@ -0,0 +1,496 @@
+use std::{
+    collections::{BTreeMap, BTreeSet, HashMap},
+    marker::PhantomData,
+    ops::Range,
+};
+
+use geo_types::GeometryCollection;
+
+use crate::{
+    euclid::Point2D,
+    render::view_state::ViewState,
+    sdf::{
+        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,
+    },
+};
+
+struct PatternDependency;
+
+#[derive(Clone, Debug)]
+pub struct SymbolVertex {
+    labelAnchor: Point2D<f64, TileSpace>,
+    o: Point2D<f64, TileSpace>,
+    glyphOffsetY: f64,
+    tx: u16,
+    ty: u16,
+    sizeData: Range<f64>,
+    isSDF: bool,
+    pixelOffset: Point2D<f64, TileSpace>,
+    minFontScale: Point2D<f64, TileSpace>,
+}
+
+impl SymbolVertex {
+    pub fn new(
+        labelAnchor: Point2D<f64, TileSpace>,
+        o: Point2D<f64, TileSpace>,
+        glyphOffsetY: f64,
+        tx: u16,
+        ty: u16,
+        sizeData: Range<f64>,
+        isSDF: bool,
+        pixelOffset: Point2D<f64, TileSpace>,
+        minFontScale: Point2D<f64, TileSpace>,
+    ) -> SymbolVertex {
+        Self {
+            labelAnchor,
+            o,
+            glyphOffsetY,
+            tx,
+            ty,
+            sizeData,
+            isSDF,
+            pixelOffset,
+            minFontScale,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct DynamicVertex {
+    anchorPoint: Point2D<f64, TileSpace>,
+    labelAngle: f64,
+}
+#[derive(Copy, Clone, Debug)]
+pub struct OpacityVertex {
+    placed: bool,
+    opacity: f64,
+}
+
+impl DynamicVertex {
+    pub fn new(anchorPoint: Point2D<f64, TileSpace>, labelAngle: f64) -> Self {
+        Self {
+            anchorPoint,
+            labelAngle,
+        }
+    }
+}
+
+impl OpacityVertex {
+    pub fn new(placed: bool, opacity: f64) -> Self {
+        Self { placed, opacity }
+    }
+}
+
+pub type VertexVector = Vec<SymbolVertex>;
+pub type DynamicVertexVector = Vec<DynamicVertex>;
+pub type OpacityVertexVector = Vec<OpacityVertex>;
+#[derive(Default, Clone, Debug)]
+pub struct SymbolTextAttributes;
+#[derive(Default, Clone, Debug)]
+pub struct SymbolSizeBinder;
+
+impl SymbolSizeBinder {
+    pub fn getVertexSizeData(&self, feature: &SymbolGeometryTileFeature) -> Range<f64> {
+        // TODO ConstantSymbolSizeBinder
+        return 0.0..0.0;
+    }
+}
+
+#[derive(Default, Clone, Debug)]
+struct FeatureSortOrder;
+#[derive(Default, Clone, Debug)]
+pub struct TriangleIndexVector {
+    indices: Vec<u16>,
+}
+impl TriangleIndexVector {
+    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);
+    }
+
+    pub fn len(&self) -> usize {
+        //  todo!()
+        // put them flat into the buffer .len() should return the count of indices
+        self.indices.len()
+    }
+}
+struct UploadPass;
+struct SymbolInstanceReferences;
+struct RenderLayer;
+struct CrossTileSymbolLayerIndex;
+struct BucketPlacementData;
+struct Placement;
+type TransformState = ViewState;
+struct RenderTile;
+
+#[derive(Copy, Clone, Debug)]
+pub struct Segment<T> {
+    pub vertexOffset: usize,
+    pub indexOffset: usize,
+    pub vertexLength: usize,
+    pub indexLength: 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 sortKey: f64,
+
+    pub _phandom_data: PhantomData<T>,
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct PlacedSymbol {
+    pub anchorPoint: Point2D<f64, TileSpace>,
+    pub segment: usize,
+    pub lowerSize: f64,
+    pub upperSize: f64,
+    pub lineOffset: [f64; 2],
+    pub writingModes: WritingModeType,
+    pub line: GeometryCoordinates,
+    pub tileDistances: Vec<f64>,
+    pub glyphOffsets: Vec<f64>,
+    pub hidden: bool,
+    pub vertexStartIndex: usize,
+    /// The crossTileID is only filled/used on the foreground for variable text anchors
+    pub crossTileID: u32,
+    /// The placedOrientation is only used when symbol layer's property is set to
+    /// support placement for orientation variants.
+    pub placedOrientation: Option<TextWritingModeType>,
+    pub angle: f64,
+    /// Reference to placed icon, only applicable for text symbols.
+    pub placedIconIndex: Option<usize>,
+}
+
+type PatternLayerMap = HashMap<String, PatternDependency>;
+
+type SegmentVector<T> = Vec<Segment<T>>;
+
+#[derive(Default, Clone, Debug)]
+pub struct SymbolBucketBuffer {
+    pub sharedVertices: Box<VertexVector>,
+    pub sharedDynamicVertices: Box<DynamicVertexVector>,
+    pub sharedOpacityVertices: Box<OpacityVertexVector>,
+
+    // type TriangleIndexVector = gfx::IndexVector<gfx::Triangles>,
+    pub sharedTriangles: Box<TriangleIndexVector>,
+    pub triangles: Box<TriangleIndexVector>,
+    //TODO triangles: &TriangleIndexVector = *sharedTriangles,
+    pub segments: SegmentVector<SymbolTextAttributes>,
+    pub placedSymbols: 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
+}
+
+#[derive(Clone, Debug)]
+pub struct PaintProperties {
+    //    iconBinders: SymbolIconProgram::Binders,
+    //    textBinders:  SymbolSDFTextProgram::Binders,
+}
+
+//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
+//}
+
+//struct CollisionBoxBuffer : public CollisionBuffer {
+//    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
+//}
+//struct CollisionCircleBuffer : public CollisionBuffer {
+//    //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
+//}
+
+#[derive(Clone, Debug)]
+pub struct SymbolBucket {
+    layout: SymbolLayoutProperties_PossiblyEvaluated,
+    bucketLeaderID: String,
+    sortedAngle: f64,
+
+    // Flags
+    // TODO what are the initial values?
+    iconsNeedLinear: bool,
+    sortFeaturesByY: bool,
+    staticUploaded: bool,
+    placementChangesUploaded: bool,
+    dynamicUploaded: bool,
+    sortUploaded: bool,
+    iconsInText: bool,
+    // Set and used by placement.
+    pub justReloaded: bool,
+    hasVariablePlacement: bool,
+    hasUninitializedSymbols: bool,
+
+    //pub symbolInstances: Vec<SymbolInstance>,
+    pub sortKeyRanges: Vec<SortKeyRange>,
+
+    pub paintProperties: HashMap<String, PaintProperties>,
+
+    pub textSizeBinder: Box<SymbolSizeBinder>,
+    //type VertexVector = gfx::VertexVector<SymbolLayoutVertex>,
+    //type VertexBuffer = gfx::VertexBuffer<SymbolLayoutVertex>,
+    //type DynamicVertexVector = gfx::VertexVector<gfx::Vertex<SymbolDynamicLayoutAttributes>>,
+    //type DynamicVertexBuffer = gfx::VertexBuffer<gfx::Vertex<SymbolDynamicLayoutAttributes>>,
+    //type OpacityVertexVector = gfx::VertexVector<gfx::Vertex<SymbolOpacityAttributes>>,
+    //type OpacityVertexBuffer = gfx::VertexBuffer<gfx::Vertex<SymbolOpacityAttributes>>,
+    pub text: SymbolBucketBuffer,
+
+    pub iconSizeBinder: Box<SymbolSizeBinder>,
+    pub icon: SymbolBucketBuffer,
+    pub sdfIcon: SymbolBucketBuffer,
+
+    //type CollisionVertexVector = gfx::VertexVector<gfx::Vertex<CollisionBoxLayoutAttributes>>,
+    //type CollisionDynamicVertexVector = gfx::VertexVector<gfx::Vertex<CollisionBoxDynamicAttributes>>,
+
+    // iconCollisionBox: Box<CollisionBoxBuffer>,
+    // textCollisionBox:   Box<CollisionBoxBuffer>,
+    // iconCollisionCircle:  Box<CollisionCircleBuffer>,
+    // textCollisionCircle: Box<CollisionCircleBuffer> ,
+    tilePixelRatio: f64,
+    bucketInstanceId: u32,
+    allowVerticalPlacement: bool,
+    placementModes: Vec<TextWritingModeType>,
+    hasFormatSectionOverrides_: Option<bool>,
+
+    featureSortOrder: FeatureSortOrder,
+
+    uploaded: bool,
+}
+
+static maxBucketInstanceId: u32 = 0;
+
+impl SymbolBucket {
+    pub fn new(
+        layout_: SymbolLayoutProperties_PossiblyEvaluated,
+        paintProperties_: &BTreeMap<String, LayerProperties>,
+        textSize: &PropertyValue<f64>,
+        iconSize: &PropertyValue<f64>,
+        zoom: f64,
+        iconsNeedLinear_: bool,
+        sortFeaturesByY_: bool,
+        bucketName_: String,
+        symbolInstances_: Vec<SymbolInstance>,
+        sortKeyRanges_: Vec<SortKeyRange>,
+        tilePixelRatio_: f64,
+        allowVerticalPlacement_: bool,
+        placementModes_: Vec<TextWritingModeType>,
+        iconsInText_: bool,
+    ) -> Self {
+        // TODO maxBucketInstanceId += 1;
+        let mut self_ = Self {
+            layout: layout_,
+            bucketLeaderID: bucketName_,
+            sortedAngle: f64::MAX,
+            iconsNeedLinear: iconsNeedLinear_ || iconSize.isDataDriven() || !iconSize.isZoomant(),
+            sortFeaturesByY: sortFeaturesByY_,
+            staticUploaded: false,
+            placementChangesUploaded: false,
+            dynamicUploaded: false,
+            sortUploaded: false,
+            iconsInText: false,
+            justReloaded: false,
+            hasVariablePlacement: false,
+            hasUninitializedSymbols: false,
+            // TODO symbolInstances: symbolInstances_,
+            sortKeyRanges: sortKeyRanges_,
+            paintProperties: Default::default(),
+            textSizeBinder: Default::default(),
+            // TODO textSizeBinder: SymbolSizeBinder::create(zoom, textSize, TextSize::defaultValue()),
+            text: SymbolBucketBuffer::default(),
+            iconSizeBinder: Default::default(),
+            // TODO iconSizeBinder: SymbolSizeBinder::create(zoom, iconSize, IconSize::defaultValue()),
+            icon: SymbolBucketBuffer::default(),
+            sdfIcon: SymbolBucketBuffer::default(),
+            tilePixelRatio: tilePixelRatio_,
+            bucketInstanceId: maxBucketInstanceId,
+            allowVerticalPlacement: allowVerticalPlacement_,
+            placementModes: placementModes_,
+            hasFormatSectionOverrides_: None,
+            featureSortOrder: FeatureSortOrder::default(),
+            uploaded: false,
+        };
+
+        // 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_
+    }
+
+    // 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.
+    pub fn upload(&self, pass: &UploadPass) {
+        todo!()
+    }
+    pub fn hasData(&self) -> bool {
+        // todo!()
+        true
+    }
+
+    pub fn hasTextData(&self) -> bool {
+        todo!()
+    }
+    pub fn hasIconData(&self) -> bool {
+        todo!()
+    }
+    pub fn hasSdfIconData(&self) -> bool {
+        todo!()
+    }
+    pub fn hasIconCollisionBoxData(&self) -> bool {
+        todo!()
+    }
+    pub fn hasIconCollisionCircleData(&self) -> bool {
+        todo!()
+    }
+    pub fn hasTextCollisionBoxData(&self) -> bool {
+        todo!()
+    }
+    pub fn hasTextCollisionCircleData(&self) -> bool {
+        todo!()
+    }
+    pub fn hasFormatSectionOverrides(&self) -> bool {
+        //  todo!()
+        false
+    }
+
+    pub fn sortFeatures(&self, angle: f64) {
+        todo!()
+    }
+    // Returns references to the `symbolInstances` items, sorted by viewport Y.
+    pub fn getSortedSymbols(&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`.
+    pub fn getSymbols(&self, sortKeyRange: &Option<SortKeyRange>) -> SymbolInstanceReferences {
+        todo!()
+    }
+
+    //    pub fn getOrCreateIconCollisionBox(&self,) -> &CollisionBoxBuffer{
+    //        if (!self.iconCollisionBox) {
+    //            self.iconCollisionBox = std::make_unique<CollisionBoxBuffer>()
+    //        }
+    //        return *self.iconCollisionBox
+    //    }
+    //    pub fn getOrCreateTextCollisionBox(&self,) -> &CollisionBoxBuffer{
+    //        if (!self.textCollisionBox) {
+    //            self.textCollisionBox = std::make_unique<CollisionBoxBuffer>()
+    //        }
+    //        return *self.textCollisionBox
+    //    }
+    //    pub fn    getOrCreateIconCollisionCircleBuffer(&self,)  -> &CollisionCircleBuffer{
+    //        if (!self.iconCollisionCircle) {
+    //            self.iconCollisionCircle = std::make_unique<CollisionCircleBuffer>()
+    //        }
+    //        return *self.iconCollisionCircle
+    //    }
+    //    pub fn  getOrCreateTextCollisionCircleBuffer(&self,) -> &CollisionCircleBuffer {
+    //        if (!self.textCollisionCircle) {
+    //            self.textCollisionCircle = std::make_unique<CollisionCircleBuffer>(),
+    //        }
+    //        return *self.textCollisionCircle
+    //    }
+
+    pub fn getQueryRadius(&self, layer: RenderLayer) -> f64 {
+        return 0.;
+    }
+
+    pub fn needsUpload(&self) -> bool {
+        return self.hasData() && !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.
+    pub fn addFeature(
+        &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.
+    pub fn registerAtCrossTileIndex(
+        &self,
+        cross_tile_index: &CrossTileSymbolLayerIndex,
+        render_tile: &RenderTile,
+    ) -> (u32, bool) {
+        todo!()
+    }
+    // Places this bucket to the given placement.
+    pub fn place(
+        &self,
+        placement: &Placement,
+        bucket_placement_data: &BucketPlacementData,
+        values: &BTreeSet<u32>,
+    ) {
+        todo!()
+    }
+    pub fn updateVertices(
+        placement: &Placement,
+        updateOpacities: bool,
+        transform_state: &TransformState,
+        render_tile: &RenderTile,
+        values: &BTreeSet<u32>,
+    ) {
+        todo!()
+    }
+}
diff --git a/maplibre/src/sdf/collision_feature.rs b/maplibre/src/sdf/collision_feature.rs
new file mode 100644
index 000000000..25ff0b9fe
--- /dev/null
+++ b/maplibre/src/sdf/collision_feature.rs
@@ -0,0 +1,390 @@
+// This file was fully translated
+
+use crate::{
+    euclid::{Box2D, Point2D, Vector2D},
+    sdf::{
+        geometry::{
+            convert_point_f64, convert_point_i16, feature_index::IndexedSubfeature, Anchor,
+        },
+        geometry_tile_data::{GeometryCoordinate, GeometryCoordinates},
+        glyph::Shaping,
+        grid_index::Circle,
+        shaping::{Padding, PositionedIcon},
+        style_types::SymbolPlacementType,
+        util::math::{deg2radf, rotate, MinMax},
+        ScreenSpace, TileSpace,
+    },
+};
+
+#[derive(Clone)]
+pub struct CollisionFeature {
+    pub boxes: Vec<CollisionBox>,
+    pub indexedFeature: IndexedSubfeature,
+    pub alongLine: bool,
+}
+
+impl CollisionFeature {
+    pub fn new(
+        line: &GeometryCoordinates,
+        anchor: &Anchor,
+        top: f64,
+        bottom: f64,
+        left: f64,
+        right: f64,
+        collisionPadding: Option<Padding>,
+        boxScale: f64,
+        padding: f64,
+        placement: SymbolPlacementType,
+        indexedFeature_: IndexedSubfeature,
+        overscaling: f64,
+        rotate_: f64,
+    ) -> Self {
+        let mut self_ = Self {
+            boxes: vec![],
+            indexedFeature: indexedFeature_,
+            alongLine: placement != SymbolPlacementType::Point,
+        };
+
+        if (top == 0. && bottom == 0. && left == 0. && right == 0.) {
+            return self_;
+        }
+
+        let mut y1 = top * boxScale - padding;
+        let mut y2 = bottom * boxScale + padding;
+        let mut x1 = left * boxScale - padding;
+        let mut x2 = right * boxScale + padding;
+
+        if let Some(collisionPadding) = collisionPadding {
+            x1 -= collisionPadding.left * boxScale;
+            y1 -= collisionPadding.top * boxScale;
+            x2 += collisionPadding.right * boxScale;
+            y2 += collisionPadding.bottom * boxScale;
+        }
+
+        if (self_.alongLine) {
+            let mut height = y2 - y1;
+            let length = x2 - x1;
+
+            if (height <= 0.0) {
+                return self_;
+            }
+
+            height = 10.0 * boxScale.max(height);
+
+            let anchorPoint = convert_point_i16(&anchor.point);
+            self_.bboxifyLabel(
+                line,
+                &anchorPoint,
+                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 rotateRadians = deg2radf(rotate_);
+
+                let tl = rotate(&Vector2D::<_, TileSpace>::new(x1, y1), rotateRadians);
+                let tr = rotate(&Vector2D::<_, TileSpace>::new(x2, y1), rotateRadians);
+                let bl = rotate(&Vector2D::<_, TileSpace>::new(x1, y2), rotateRadians);
+                let br = rotate(&Vector2D::<_, TileSpace>::new(x2, y2), rotateRadians);
+
+                // 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 xMin = [tl.x, tr.x, bl.x, br.x].min_value();
+                let xMax = [tl.x, tr.x, bl.x, br.x].max_value();
+                let yMin = [tl.y, tr.y, bl.y, br.y].min_value();
+                let yMax = [tl.y, tr.y, bl.y, br.y].max_value();
+
+                self_.boxes.push(CollisionBox {
+                    anchor: anchor.point,
+                    x1: xMin,
+                    y1: yMin,
+                    x2: xMax,
+                    y2: yMax,
+                    signedDistanceFromAnchor: 0.0,
+                });
+            } else {
+                self_.boxes.push(CollisionBox {
+                    anchor: anchor.point,
+                    x1,
+                    y1,
+                    x2,
+                    y2,
+                    signedDistanceFromAnchor: 0.0,
+                });
+            }
+        }
+        self_
+    }
+
+    // for text
+    pub fn new_from_text(
+        line: &GeometryCoordinates,
+        anchor: &Anchor,
+        shapedText: Shaping,
+        boxScale: f64,
+        padding: f64,
+        placement: SymbolPlacementType,
+        indexedFeature_: IndexedSubfeature,
+        overscaling: f64,
+        rotate: f64,
+    ) -> Self {
+        Self::new(
+            line,
+            anchor,
+            shapedText.top,
+            shapedText.bottom,
+            shapedText.left,
+            shapedText.right,
+            None,
+            boxScale,
+            padding,
+            placement,
+            indexedFeature_,
+            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
+    pub fn new_from_icon(
+        line: &GeometryCoordinates,
+        anchor: &Anchor,
+        shapedIcon: &Option<PositionedIcon>,
+        boxScale: f64,
+        padding: f64,
+        indexedFeature_: IndexedSubfeature,
+        rotate: f64,
+    ) -> Self {
+        Self::new(
+            line,
+            anchor,
+            if let Some(shapedIcon) = &shapedIcon {
+                shapedIcon.top
+            } else {
+                0.
+            },
+            if let Some(shapedIcon) = &shapedIcon {
+                shapedIcon.bottom
+            } else {
+                0.
+            },
+            if let Some(shapedIcon) = &shapedIcon {
+                shapedIcon.left
+            } else {
+                0.
+            },
+            if let Some(shapedIcon) = &shapedIcon {
+                shapedIcon.right
+            } else {
+                0.
+            },
+            if let Some(shapedIcon) = &shapedIcon {
+                Some(shapedIcon.collisionPadding)
+            } else {
+                None
+            },
+            boxScale,
+            padding,
+            SymbolPlacementType::Point,
+            indexedFeature_,
+            1.,
+            rotate,
+        )
+    }
+
+    fn bboxifyLabel(
+        &mut self,
+        line: &GeometryCoordinates,
+        anchorPoint: &GeometryCoordinate,
+        segment: usize,
+        labelLength: f64,
+        boxSize: f64,
+        overscaling: f64,
+    ) {
+        let step = boxSize / 2.;
+        let nBoxes = ((labelLength / 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 overscalingPaddingFactor = 1. + 0.4 * (overscaling as f64).log2();
+        let nPitchPaddingBoxes = ((nBoxes as f64 * overscalingPaddingFactor / 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 firstBoxOffset = -boxSize / 2.;
+
+        let mut p = anchorPoint;
+        let mut index = segment + 1;
+        let mut anchorDistance = firstBoxOffset;
+        let labelStartDistance = -labelLength / 2.;
+        let paddingStartDistance = labelStartDistance - labelLength / 8.;
+
+        // move backwards along the line to the first segment the label appears on
+        loop {
+            if (index == 0) {
+                if (anchorDistance > labelStartDistance) {
+                    // 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;
+            anchorDistance -= convert_point_f64(&line[index]).distance_to(convert_point_f64(p));
+            p = &line[index];
+
+            if !(anchorDistance > paddingStartDistance) {
+                break;
+            }
+        }
+
+        let mut segmentLength =
+            convert_point_f64(&line[index]).distance_to(convert_point_f64(&line[index + 1]));
+
+        for i in -nPitchPaddingBoxes..nBoxes + nPitchPaddingBoxes {
+            // the distance the box will be from the anchor
+            let boxOffset = i as f64 * step;
+            let mut boxDistanceToAnchor = labelStartDistance + boxOffset as f64;
+
+            // make the distance between pitch padding boxes bigger
+            if (boxOffset < 0.) {
+                boxDistanceToAnchor += boxOffset;
+            }
+            if (boxOffset > labelLength) {
+                boxDistanceToAnchor += boxOffset - labelLength;
+            }
+
+            if (boxDistanceToAnchor < anchorDistance) {
+                // 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 (anchorDistance + segmentLength < boxDistanceToAnchor) {
+                anchorDistance += segmentLength;
+                index += 1;
+
+                // There isn't enough room before the end of the line.
+                if (index + 1 >= line.len()) {
+                    return;
+                }
+
+                segmentLength = 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 segmentBoxDistance = boxDistanceToAnchor - anchorDistance;
+
+            let p0 = line[index];
+            let p1 = line[index + 1];
+
+            let boxAnchor = Point2D::new(
+                p0.x as f64 + segmentBoxDistance / segmentLength * (p1.x - p0.x) as f64,
+                p0.y as f64 + segmentBoxDistance / segmentLength * (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 paddedAnchorDistance = if (boxDistanceToAnchor - firstBoxOffset).abs() < step {
+                0.0
+            } else {
+                (boxDistanceToAnchor - firstBoxOffset) * 0.8
+            };
+
+            self.boxes.push(CollisionBox {
+                anchor: boxAnchor,
+                x1: -boxSize / 2.,
+                y1: -boxSize / 2.,
+                x2: boxSize / 2.,
+                y2: boxSize / 2.,
+                signedDistanceFromAnchor: paddedAnchorDistance,
+            });
+        }
+    }
+}
+
+#[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 signedDistanceFromAnchor: f64,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum ProjectedCollisionBox {
+    Circle(Circle<f64>),
+    Box(Box2D<f64, ScreenSpace>),
+}
+
+impl Default for ProjectedCollisionBox {
+    fn default() -> Self {
+        return Self::Box(Box2D::zero());
+    }
+}
+
+impl ProjectedCollisionBox {
+    pub fn box_(&self) -> &Box2D<f64, ScreenSpace> {
+        match self {
+            ProjectedCollisionBox::Circle(_) => panic!("not a box"),
+            ProjectedCollisionBox::Box(box_) => box_,
+        }
+    }
+
+    pub fn circle(&self) -> &Circle<f64> {
+        match self {
+            ProjectedCollisionBox::Circle(circle) => circle,
+            ProjectedCollisionBox::Box(_) => panic!("not a circle"),
+        }
+    }
+
+    pub fn isBox(&self) -> bool {
+        match self {
+            ProjectedCollisionBox::Circle(_) => false,
+            ProjectedCollisionBox::Box(_) => true,
+        }
+    }
+
+    pub fn isCircle(&self) -> bool {
+        match self {
+            ProjectedCollisionBox::Circle(_) => true,
+            ProjectedCollisionBox::Box(_) => false,
+        }
+    }
+}
diff --git a/maplibre/src/sdf/collision_index.rs b/maplibre/src/sdf/collision_index.rs
new file mode 100644
index 000000000..ed3d8bb61
--- /dev/null
+++ b/maplibre/src/sdf/collision_index.rs
@@ -0,0 +1,617 @@
+// File fully translated except for to-do comments
+
+use std::collections::HashMap;
+
+use bitflags::bitflags;
+use cgmath::{Matrix4, Vector4};
+
+use crate::{
+    coords::EXTENT,
+    euclid::{Box2D, Point2D},
+    render::{camera::ModelViewProjection, view_state::ViewState},
+    sdf::{
+        buckets::symbol_bucket::PlacedSymbol,
+        collision_feature::{CollisionBox, CollisionFeature, ProjectedCollisionBox},
+        geometry::feature_index::IndexedSubfeature,
+        grid_index::{Circle, GridIndex},
+        layout::symbol_projection::{placeFirstAndLastGlyph, project, TileDistance},
+        util::geo::ScreenLineString,
+        MapMode, ScreenSpace, TileSpace,
+    },
+};
+
+type TransformState = ViewState;
+
+type CollisionBoundaries = Box2D<f64, ScreenSpace>; // [f64; 4]; // [x1, y1, x2, y2]
+
+bitflags! {
+    /// Represents a set of flags.
+    #[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 {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+#[derive(Default)]
+struct IntersectStatus {
+    flags: IntersectStatusFlags,
+    // Assuming tile border divides box in two sections
+    minSectionLength: 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 viewportPaddingDefault: f64 = 100.;
+// Viewport padding must be much larger for static tiles to avoid clipped labels.
+const viewportPaddingForStaticTiles: f64 = 1024.;
+
+fn findViewportPadding(transformState: &TransformState, mapMode: MapMode) -> f64 {
+    if (mapMode == MapMode::Tile) {
+        return viewportPaddingForStaticTiles;
+    }
+    return if (transformState.camera().get_pitch().0 != 0.0) {
+        viewportPaddingDefault * 2.
+    } else {
+        viewportPaddingDefault
+    };
+}
+
+type CollisionGrid = GridIndex<IndexedSubfeature>;
+pub struct CollisionIndex {
+    transformState: TransformState,
+    viewportPadding: f64,
+    collisionGrid: CollisionGrid,
+    ignoredGrid: CollisionGrid,
+    screenRightBoundary: f64,
+    screenBottomBoundary: f64,
+    gridRightBoundary: f64,
+    gridBottomBoundary: f64,
+    pitchFactor: f64,
+}
+
+impl CollisionIndex {
+    pub fn new(transformState: &TransformState, mapMode: MapMode) -> Self {
+        let viewportPadding = findViewportPadding(transformState, mapMode);
+        Self {
+            transformState: transformState.clone(),
+            viewportPadding: viewportPadding,
+            collisionGrid: CollisionGrid::new(
+                transformState.width() + 2. * viewportPadding,
+                transformState.height() + 2. * viewportPadding,
+                25,
+            ),
+            ignoredGrid: CollisionGrid::new(
+                transformState.width() + 2. * viewportPadding,
+                transformState.height() + 2. * viewportPadding,
+                25,
+            ),
+            screenRightBoundary: transformState.width() + viewportPadding,
+            screenBottomBoundary: transformState.height() + viewportPadding,
+            gridRightBoundary: transformState.width() + 2. * viewportPadding,
+            gridBottomBoundary: transformState.height() + 2. * viewportPadding,
+            pitchFactor: transformState.camera().get_pitch().0.cos()
+                * transformState.camera_to_center_distance(),
+        }
+    }
+
+    pub fn intersectsTileEdges(
+        &self,
+        box_: &CollisionBox,
+        shift: Point2D<f64, ScreenSpace>,
+        posMatrix: &ModelViewProjection,
+        textPixelRatio: f64,
+        tileEdges: CollisionBoundaries,
+    ) -> IntersectStatus {
+        let boundaries =
+            self.getProjectedCollisionBoundaries(posMatrix, shift, textPixelRatio, 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 tileX1 = tileEdges.min.x;
+        let tileY1 = tileEdges.min.y;
+        let tileX2 = tileEdges.max.x;
+        let tileY2 = tileEdges.max.y;
+
+        // Check left border
+        let mut minSectionLength = ((tileX1 - x1).min(x2 - tileX1)) as i32;
+        if (minSectionLength <= 0) {
+            // Check right border
+            minSectionLength = ((tileX2 - x1).min(x2 - tileX2)) as i32;
+        }
+        if (minSectionLength > 0) {
+            result.flags |= IntersectStatusFlags::VerticalBorders;
+            result.minSectionLength = minSectionLength;
+        }
+        // Check top border
+        minSectionLength = ((tileY1 - y1).min(y2 - tileY1)) as i32;
+        if (minSectionLength <= 0) {
+            // Check bottom border
+            minSectionLength = ((tileY2 - y1).min(y2 - tileY2)) as i32;
+        }
+        if (minSectionLength > 0) {
+            result.flags |= IntersectStatusFlags::HorizontalBorders;
+            result.minSectionLength = (result.minSectionLength).min(minSectionLength);
+        }
+        return result;
+    }
+
+    pub fn placeFeature<F>(
+        &self,
+        feature: &CollisionFeature,
+        shift: Point2D<f64, ScreenSpace>,
+        posMatrix: &ModelViewProjection,
+        labelPlaneMatrix: &Matrix4<f64>,
+        textPixelRatio: f64,
+        symbol: &PlacedSymbol,
+        scale: f64,
+        fontSize: f64,
+        allowOverlap: bool,
+        pitchWithMap: bool,
+        collisionDebug: bool,
+        avoidEdges: Option<CollisionBoundaries>,
+        collisionGroupPredicate: Option<F>,
+        projectedBoxes: &mut Vec<ProjectedCollisionBox>, /*out*/
+    ) -> (bool, bool)
+    where
+        F: Fn(&IndexedSubfeature) -> bool,
+    {
+        assert!(projectedBoxes.is_empty());
+        if (!feature.alongLine) {
+            let box_ = feature.boxes.first().unwrap();
+            let collisionBoundaries =
+                self.getProjectedCollisionBoundaries(posMatrix, shift, textPixelRatio, box_);
+            projectedBoxes.push(ProjectedCollisionBox::Box(collisionBoundaries));
+
+            if let Some(avoidEdges) = avoidEdges {
+                if !self.isInsideTile(&collisionBoundaries, &avoidEdges) {
+                    return (false, false);
+                }
+            }
+
+            if !self.isInsideGrid(&collisionBoundaries)
+                || (!allowOverlap
+                    && self.collisionGrid.hit_test(
+                        projectedBoxes.last().unwrap().box_(),
+                        collisionGroupPredicate,
+                    ))
+            {
+                return (false, false);
+            }
+
+            return (true, self.isOffscreen(&collisionBoundaries));
+        } else {
+            return self.placeLineFeature(
+                feature,
+                posMatrix,
+                labelPlaneMatrix,
+                textPixelRatio,
+                symbol,
+                scale,
+                fontSize,
+                allowOverlap,
+                pitchWithMap,
+                collisionDebug,
+                avoidEdges,
+                collisionGroupPredicate,
+                projectedBoxes,
+            );
+        }
+    }
+
+    pub fn insertFeature(
+        &mut self,
+        feature: CollisionFeature,
+        projectedBoxes: &Vec<ProjectedCollisionBox>,
+        ignorePlacement: bool,
+        bucketInstanceId: u32,
+        collisionGroupId: u16,
+    ) {
+        if (feature.alongLine) {
+            for circle in projectedBoxes {
+                if (!circle.isCircle()) {
+                    continue;
+                }
+
+                if (ignorePlacement) {
+                    self.ignoredGrid.insert_circle(
+                        IndexedSubfeature::new(
+                            feature.indexedFeature.clone(),
+                            bucketInstanceId,
+                            collisionGroupId,
+                        ), // FIXME clone() should not be needed?
+                        *circle.circle(),
+                    );
+                } else {
+                    self.collisionGrid.insert_circle(
+                        IndexedSubfeature::new(
+                            feature.indexedFeature.clone(),
+                            bucketInstanceId,
+                            collisionGroupId,
+                        ), // FIXME clone() should not be needed?
+                        *circle.circle(),
+                    );
+                }
+            }
+        } else if (!projectedBoxes.is_empty()) {
+            assert!(projectedBoxes.len() == 1);
+            let box_ = projectedBoxes[0];
+            // TODO assert!(box_.isBox());
+            if (ignorePlacement) {
+                self.ignoredGrid.insert(
+                    IndexedSubfeature::new(
+                        feature.indexedFeature,
+                        bucketInstanceId,
+                        collisionGroupId,
+                    ),
+                    *box_.box_(),
+                );
+            } else {
+                self.collisionGrid.insert(
+                    IndexedSubfeature::new(
+                        feature.indexedFeature,
+                        bucketInstanceId,
+                        collisionGroupId,
+                    ),
+                    *box_.box_(),
+                );
+            }
+        }
+    }
+
+    pub fn queryRenderedSymbols(
+        &self,
+        line_string: &ScreenLineString,
+    ) -> HashMap<u32, Vec<IndexedSubfeature>> {
+        todo!()
+    }
+
+    pub fn projectTileBoundaries(&self, posMatrix: &ModelViewProjection) -> CollisionBoundaries {
+        let topLeft = self.projectPoint(posMatrix, &Point2D::zero());
+        let bottomRight = self.projectPoint(posMatrix, &Point2D::new(EXTENT, EXTENT)); // FIXME: maplibre-native uses here 8192 for extent
+
+        return CollisionBoundaries::new(
+            Point2D::new(topLeft.x, topLeft.y),
+            Point2D::new(bottomRight.x, bottomRight.y),
+        );
+    }
+
+    pub fn getTransformState(&self) -> &TransformState {
+        return &self.transformState;
+    }
+
+    pub fn getViewportPadding(&self) -> f64 {
+        return self.viewportPadding;
+    }
+}
+
+impl CollisionIndex {
+    fn isOffscreen(&self, boundaries: &CollisionBoundaries) -> bool {
+        return boundaries.max.x < self.viewportPadding
+            || boundaries.min.x >= self.screenRightBoundary
+            || boundaries.max.y < self.viewportPadding
+            || boundaries.min.y >= self.screenBottomBoundary;
+    }
+    fn isInsideGrid(&self, boundaries: &CollisionBoundaries) -> bool {
+        return boundaries.max.x >= 0.
+            && boundaries.min.x < self.gridRightBoundary
+            && boundaries.max.y >= 0.
+            && boundaries.min.y < self.gridBottomBoundary;
+    }
+
+    fn isInsideTile(
+        &self,
+        boundaries: &CollisionBoundaries,
+        tileBoundaries: &CollisionBoundaries,
+    ) -> bool {
+        return boundaries.min.x >= tileBoundaries.min.x
+            && boundaries.min.y >= tileBoundaries.min.y
+            && boundaries.max.x < tileBoundaries.max.x
+            && boundaries.max.y < tileBoundaries.max.y;
+    }
+
+    fn overlapsTile(
+        &self,
+        boundaries: &CollisionBoundaries,
+        tileBoundaries: &CollisionBoundaries,
+    ) -> bool {
+        return boundaries.min.x < tileBoundaries.max.x
+            && boundaries.max.x > tileBoundaries.min.x
+            && boundaries.min.y < tileBoundaries.max.y
+            && boundaries.max.y > tileBoundaries.min.y;
+    }
+
+    fn placeLineFeature<F>(
+        &self,
+        feature: &CollisionFeature,
+        posMatrix: &ModelViewProjection,
+        labelPlaneMatrix: &Matrix4<f64>,
+        textPixelRatio: f64,
+        symbol: &PlacedSymbol,
+        scale: f64,
+        fontSize: f64,
+        allowOverlap: bool,
+        pitchWithMap: bool,
+        collisionDebug: bool,
+        avoidEdges: Option<CollisionBoundaries>,
+        collisionGroupPredicate: Option<F>,
+        projectedBoxes: &mut Vec<ProjectedCollisionBox>, /*out*/
+    ) -> (bool, bool)
+    where
+        F: Fn(&IndexedSubfeature) -> bool,
+    {
+        assert!(feature.alongLine);
+        assert!(projectedBoxes.is_empty());
+        let tileUnitAnchorPoint = symbol.anchorPoint;
+        let projectedAnchor = self.projectAnchor(posMatrix, &tileUnitAnchorPoint);
+
+        let fontScale = fontSize / 24.;
+        let lineOffsetX = symbol.lineOffset[0] * fontSize;
+        let lineOffsetY = symbol.lineOffset[1] * fontSize;
+
+        let labelPlaneAnchorPoint = project(tileUnitAnchorPoint, labelPlaneMatrix).0;
+
+        let firstAndLastGlyph = placeFirstAndLastGlyph(
+            fontScale,
+            lineOffsetX,
+            lineOffsetY,
+            /*flip*/ false,
+            labelPlaneAnchorPoint,
+            tileUnitAnchorPoint,
+            symbol,
+            labelPlaneMatrix,
+            /*return tile distance*/ true,
+        );
+
+        let mut collisionDetected = false;
+        let mut inGrid = false;
+        let mut entirelyOffscreen = true;
+
+        let tileToViewport = projectedAnchor.0 * textPixelRatio;
+        // 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 pixelsToTileUnits = 1. / (textPixelRatio * scale);
+
+        let mut firstTileDistance = 0.;
+        let mut lastTileDistance = 0.;
+        if let Some(firstAndLastGlyph) = &firstAndLastGlyph {
+            firstTileDistance = self.approximateTileDistance(
+                firstAndLastGlyph.0.tileDistance.as_ref().unwrap(),
+                firstAndLastGlyph.0.angle,
+                pixelsToTileUnits,
+                projectedAnchor.1,
+                pitchWithMap,
+            );
+            lastTileDistance = self.approximateTileDistance(
+                firstAndLastGlyph.1.tileDistance.as_ref().unwrap(),
+                firstAndLastGlyph.1.angle,
+                pixelsToTileUnits,
+                projectedAnchor.1,
+                pitchWithMap,
+            );
+        }
+
+        let mut previousCirclePlaced = false;
+        projectedBoxes.resize(feature.boxes.len(), ProjectedCollisionBox::default());
+        for i in 0..feature.boxes.len() {
+            let circle = feature.boxes[i];
+            let boxSignedDistanceFromAnchor = circle.signedDistanceFromAnchor;
+            if (firstAndLastGlyph.is_none()
+                || (boxSignedDistanceFromAnchor < -firstTileDistance)
+                || (boxSignedDistanceFromAnchor > lastTileDistance))
+            {
+                // 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.
+                previousCirclePlaced = false;
+                continue;
+            }
+
+            let projectedPoint = self.projectPoint(posMatrix, &circle.anchor);
+            let tileUnitRadius = (circle.x2 - circle.x1) / 2.;
+            let radius = tileUnitRadius * tileToViewport;
+
+            if (previousCirclePlaced) {
+                let previousCircle = &projectedBoxes[i - 1];
+                assert!(previousCircle.isCircle());
+                let previousCenter = previousCircle.circle().center;
+                let dx = projectedPoint.x - previousCenter.x;
+                let dy = projectedPoint.y - previousCenter.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 placedTooDensely = radius * radius * 2. > dx * dx + dy * dy;
+                if (placedTooDensely) {
+                    let atLeastOneMoreCircle = (i + 1) < feature.boxes.len();
+                    if (atLeastOneMoreCircle) {
+                        let nextCircle = feature.boxes[i + 1];
+                        let nextBoxDistanceFromAnchor = nextCircle.signedDistanceFromAnchor;
+                        if ((nextBoxDistanceFromAnchor > -firstTileDistance)
+                            && (nextBoxDistanceFromAnchor < lastTileDistance))
+                        {
+                            // 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.
+                            previousCirclePlaced = false;
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            previousCirclePlaced = true;
+
+            let collisionBoundaries = CollisionBoundaries::new(
+                Point2D::new(projectedPoint.x - radius, projectedPoint.y - radius),
+                Point2D::new(projectedPoint.x + radius, projectedPoint.y + radius),
+            );
+
+            projectedBoxes[i] = ProjectedCollisionBox::Circle(Circle::new(
+                Point2D::new(projectedPoint.x, projectedPoint.y),
+                radius,
+            ));
+
+            entirelyOffscreen &= self.isOffscreen(&collisionBoundaries);
+            inGrid |= self.isInsideGrid(&collisionBoundaries);
+
+            if let Some(avoidEdges) = avoidEdges {
+                if (!self.isInsideTile(&collisionBoundaries, &avoidEdges)) {
+                    if (!collisionDebug) {
+                        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
+                        collisionDetected = true;
+                    }
+                }
+            }
+
+            if (!allowOverlap
+                && self
+                    .collisionGrid
+                    .hit_test_circle(projectedBoxes[i].circle(), collisionGroupPredicate.as_ref()))
+            {
+                if (!collisionDebug) {
+                    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
+                    collisionDetected = true;
+                }
+            }
+        }
+
+        return (
+            !collisionDetected && firstAndLastGlyph.is_some() && inGrid,
+            entirelyOffscreen,
+        );
+    }
+
+    fn approximateTileDistance(
+        &self,
+        tileDistance: &TileDistance,
+        lastSegmentAngle: f64,
+        pixelsToTileUnits: f64,
+        cameraToAnchorDistance: f64,
+        pitchWithMap: 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 incidenceStretch = if pitchWithMap {
+            1.
+        } else {
+            cameraToAnchorDistance / self.pitchFactor
+        };
+        let lastSegmentTile = tileDistance.lastSegmentViewportDistance * pixelsToTileUnits;
+        return tileDistance.prevTileDistance
+            + lastSegmentTile
+            + (incidenceStretch - 1.) * lastSegmentTile * lastSegmentAngle.sin().abs();
+    }
+
+    fn projectAnchor(
+        &self,
+        posMatrix: &ModelViewProjection,
+        point: &Point2D<f64, TileSpace>,
+    ) -> (f64, f64) {
+        let p = Vector4::new(point.x, point.y, 0., 1.);
+        let p = posMatrix.project(p); // TODO verify multiplication
+        return (
+            0.5 + 0.5 * (self.transformState.camera_to_center_distance() / p[3]),
+            p[3],
+        );
+    }
+    fn projectAndGetPerspectiveRatio(
+        &self,
+        posMatrix: &ModelViewProjection,
+        point: &Point2D<f64, TileSpace>,
+    ) -> (Point2D<f64, ScreenSpace>, f64) {
+        let p = Vector4::new(point.x, point.y, 0., 1.);
+        let p = posMatrix.project(p); // TODO verify multiplication
+        let width = self.transformState.width();
+        let height = self.transformState.height();
+        let ccd = self.transformState.camera_to_center_distance();
+        return (
+            Point2D::new(
+                ((p[0] / p[3] + 1.) / 2.) * width + self.viewportPadding,
+                ((-p[1] / p[3] + 1.) / 2.) * height + self.viewportPadding,
+            ),
+            // 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],
+        );
+    }
+    fn projectPoint(
+        &self,
+        posMatrix: &ModelViewProjection,
+        point: &Point2D<f64, TileSpace>,
+    ) -> Point2D<f64, ScreenSpace> {
+        let p = Vector4::new(point.x, point.y, 0., 1.);
+        let p = posMatrix.project(p); // TODO verify multiplication
+        let width = self.transformState.width();
+        let height = self.transformState.height();
+        return Point2D::new(
+            (((p[0] / p[3] + 1.) / 2.) * width + self.viewportPadding),
+            (((-p[1] / p[3] + 1.) / 2.) * height + self.viewportPadding),
+        );
+    }
+
+    fn getProjectedCollisionBoundaries(
+        &self,
+        posMatrix: &ModelViewProjection,
+        shift: Point2D<f64, ScreenSpace>,
+        textPixelRatio: f64,
+        box_: &CollisionBox,
+    ) -> CollisionBoundaries {
+        let (projectedPoint, tileToViewport) =
+            self.projectAndGetPerspectiveRatio(posMatrix, &box_.anchor);
+        let tileToViewport = textPixelRatio * tileToViewport;
+        let tileToViewport = 1.; // TODO
+        return CollisionBoundaries::new(
+            Point2D::new(
+                (box_.x1 + shift.x) * tileToViewport + projectedPoint.x,
+                (box_.y1 + shift.y) * tileToViewport + projectedPoint.y,
+            ),
+            Point2D::new(
+                (box_.x2 + shift.x) * tileToViewport + projectedPoint.x,
+                (box_.y2 + shift.y) * tileToViewport + projectedPoint.y,
+            ),
+        );
+    }
+}
diff --git a/maplibre/src/sdf/collision_system.rs b/maplibre/src/sdf/collision_system.rs
new file mode 100644
index 000000000..a216ce55d
--- /dev/null
+++ b/maplibre/src/sdf/collision_system.rs
@@ -0,0 +1,216 @@
+use std::borrow::Cow;
+
+use cgmath::{Matrix3, Vector3};
+
+use crate::{
+    context::MapContext,
+    coords::{EXTENT, TILE_SIZE},
+    euclid::Point2D,
+    render::{
+        eventually::{Eventually, Eventually::Initialized},
+        shaders::SDFShaderFeatureMetadata,
+        tile_view_pattern::WgpuTileViewPattern,
+        Renderer,
+    },
+    sdf::{
+        buckets::symbol_bucket::PlacedSymbol,
+        collision_feature::{CollisionBox, CollisionFeature},
+        collision_index::CollisionIndex,
+        geometry::feature_index::{IndexedSubfeature, RefIndexedSubfeature},
+        geometry_tile_data::GeometryCoordinates,
+        MapMode, SymbolBufferPool, SymbolLayersDataComponent,
+    },
+    tcs::system::{System, SystemError, SystemResult},
+};
+
+pub struct CollisionSystem {}
+
+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().unwrap().indices.end
+                    ];
+
+                    for feature in &layer.features {
+                        // calculate where tile is
+
+                        let transform = coords.transform_for_zoom(view_state.zoom());
+
+                        let posMatrix = 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 = posMatrix.get()
+                            * (scaling * (vec3 - text_anchor) + text_anchor).extend(1.0);
+                        let window = view_state.clip_to_window(&shader);
+
+                        //println!("{:?}", window);
+
+                        let anchorPoint =
+                            Point2D::new(feature.bbox.min.x as f64, feature.bbox.min.y as f64); // TODO
+
+                        let boxes = vec![CollisionBox {
+                            anchor: anchorPoint,
+                            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),
+                            signedDistanceFromAnchor: 0.0,
+                        }]; // TODO
+
+                        let mut projected_boxes = vec![];
+                        let collision_feature = CollisionFeature {
+                            boxes,
+                            indexedFeature: IndexedSubfeature {
+                                ref_: RefIndexedSubfeature {
+                                    index: 0,
+                                    sortIndex: 0,
+                                    sourceLayerName: "".to_string(),
+                                    bucketLeaderID: "".to_string(),
+                                    bucketInstanceId: 0,
+                                    collisionGroupId: 0,
+                                },
+                                sourceLayerNameCopy: "".to_string(),
+                                bucketLeaderIDCopy: "".to_string(),
+                            },
+                            alongLine: false, // false if point, else true
+                        };
+                        let (placed_text, is_offscreen) = collision_index.placeFeature(
+                            &collision_feature,
+                            Point2D::zero(), // shift
+                            &posMatrix,
+                            &posMatrix.get(), // TODO
+                            //TILE_SIZE / EXTENT,
+                            1.0,
+                            &PlacedSymbol {
+                                anchorPoint,
+                                segment: 0,
+                                lowerSize: 0.0,
+                                upperSize: 0.0,
+                                lineOffset: [0., 0.],
+                                writingModes: Default::default(),
+                                line: GeometryCoordinates(vec![anchorPoint.cast()]), // TODO can be linestring or just a single point
+                                tileDistances: vec![],                               // TODO
+                                glyphOffsets: vec![0., 0.],                          // TODO
+                                hidden: false,
+                                vertexStartIndex: 0,
+                                crossTileID: 0,
+                                placedOrientation: None,
+                                angle: 0.0,
+
+                                placedIconIndex: 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.insertFeature(
+                                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()))
+                        }
+                    }
+
+                    for entry in symbol_buffer_pool.index().get_layers(coords).unwrap() {
+                        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/font_stack.rs b/maplibre/src/sdf/font_stack.rs
new file mode 100644
index 000000000..b70baab53
--- /dev/null
+++ b/maplibre/src/sdf/font_stack.rs
@@ -0,0 +1,37 @@
+use std::collections::BTreeSet;
+
+use crate::{sdf::util::hash_combine, style::layer::StyleLayer};
+
+// An array of font names
+pub type FontStack = Vec<String>;
+pub type FontStackHash = u64;
+
+pub struct FontStackHasher;
+
+impl FontStackHasher {
+    pub fn new(fontStack: &FontStack) -> u64 {
+        let mut seed = 0;
+        for font in fontStack {
+            hash_combine(&mut seed, font);
+        }
+        return seed;
+    }
+}
+
+pub fn fontStackToString(fontStack: &FontStack) -> String {
+    return fontStack.join(",");
+}
+
+/// Statically evaluate layer properties to determine what font stacks are used.
+pub fn fontStacks(layers: &Vec<StyleLayer>) -> BTreeSet<FontStack> {
+    let mut result = BTreeSet::new();
+    for layer in layers {
+        populateFontStack(layer, &mut result);
+    }
+
+    return result;
+}
+
+pub(crate) fn populateFontStack(layer: &StyleLayer, stack: &mut BTreeSet<FontStack>) {
+    todo!()
+}
diff --git a/maplibre/src/sdf/geometry.rs b/maplibre/src/sdf/geometry.rs
new file mode 100644
index 000000000..9874edff4
--- /dev/null
+++ b/maplibre/src/sdf/geometry.rs
@@ -0,0 +1,20 @@
+use crate::{euclid::Point2D, sdf::TileSpace};
+
+pub mod feature_index;
+
+pub fn convert_point_f64<U>(point: &Point2D<i16, U>) -> Point2D<f64, U> {
+    Point2D::new(point.x as f64, point.y as f64)
+}
+
+pub fn convert_point_i16<U>(point: &Point2D<f64, U>) -> Point2D<i16, U> {
+    Point2D::new(point.x as i16, point.y as i16)
+}
+
+#[derive(Clone, Copy)]
+pub struct Anchor {
+    pub point: Point2D<f64, TileSpace>,
+    pub angle: f64,
+    pub segment: Option<usize>,
+}
+
+pub type Anchors = Vec<Anchor>;
diff --git a/maplibre/src/sdf/geometry/feature_index.rs b/maplibre/src/sdf/geometry/feature_index.rs
new file mode 100644
index 000000000..9455b68fd
--- /dev/null
+++ b/maplibre/src/sdf/geometry/feature_index.rs
@@ -0,0 +1,40 @@
+#[derive(Clone)]
+pub struct IndexedSubfeature {
+    pub ref_: RefIndexedSubfeature,
+    pub sourceLayerNameCopy: String,
+    pub bucketLeaderIDCopy: String,
+}
+
+impl IndexedSubfeature {
+    pub fn new(
+        indexedFeature: IndexedSubfeature,
+        bucketInstanceId: u32,
+        collisionGroupId: u16,
+    ) -> IndexedSubfeature {
+        IndexedSubfeature {
+            ref_: RefIndexedSubfeature {
+                index: indexedFeature.ref_.index,
+                sortIndex: indexedFeature.ref_.sortIndex,
+                sourceLayerName: indexedFeature.ref_.sourceLayerName.to_string(),
+                bucketLeaderID: indexedFeature.ref_.bucketLeaderID.to_string(),
+                bucketInstanceId,
+                collisionGroupId,
+            },
+            sourceLayerNameCopy: indexedFeature.ref_.sourceLayerName.to_string(),
+            bucketLeaderIDCopy: indexedFeature.ref_.bucketLeaderID.to_string(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct RefIndexedSubfeature {
+    pub index: usize,
+    pub sortIndex: usize,
+
+    pub sourceLayerName: String,
+    pub bucketLeaderID: String,
+
+    // Only used for symbol features
+    pub bucketInstanceId: u32,
+    pub collisionGroupId: u16,
+}
diff --git a/maplibre/src/sdf/geometry_tile_data.rs b/maplibre/src/sdf/geometry_tile_data.rs
new file mode 100644
index 000000000..24046c081
--- /dev/null
+++ b/maplibre/src/sdf/geometry_tile_data.rs
@@ -0,0 +1,77 @@
+use std::ops::Index;
+
+use crate::{
+    euclid::Point2D,
+    sdf::{layout::symbol_feature::SymbolGeometryTileFeature, TileSpace},
+};
+
+// 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
+
+pub type GeometryCoordinate = Point2D<i16, TileSpace>;
+
+#[derive(Default, Clone, Debug)]
+pub struct GeometryCoordinates(pub Vec<GeometryCoordinate>);
+impl GeometryCoordinates {
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+impl Index<usize> for GeometryCoordinates {
+    type Output = GeometryCoordinate;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
+pub type GeometryCollection = Vec<GeometryCoordinates>;
+
+// TODO: The following types are not final
+pub type Value = geo_types::Geometry;
+pub type Identifier = String;
+pub type PropertyMap = serde_json::Value;
+
+#[derive(PartialEq)]
+pub enum FeatureType {
+    Unknown = 0,
+    Point = 1,
+    LineString = 2,
+    Polygon = 3,
+}
+
+#[derive(Clone)]
+pub struct SymbolGeometryTileLayer {
+    pub name: String,
+    pub features: Vec<SymbolGeometryTileFeature>,
+}
+impl SymbolGeometryTileLayer {
+    pub fn featureCount(&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.
+    pub fn getFeature(&self, index: usize) -> Box<SymbolGeometryTileFeature> {
+        Box::new(self.features[index].clone())
+    }
+
+    pub fn getName(&self) -> &str {
+        &self.name
+    }
+}
+
+#[derive(Clone)]
+struct SymbolGeometryTileData;
+
+impl SymbolGeometryTileData {
+    pub fn clone(&self) -> Box<SymbolGeometryTileData> {
+        todo!()
+    }
+
+    // Returns the layer with the given name. The returned layer object *may*
+    // outlive the data object.
+    pub fn getLayer(&self, name: &str) -> Box<SymbolGeometryTileLayer> {
+        todo!()
+    }
+}
diff --git a/maplibre/src/sdf/glyph.rs b/maplibre/src/sdf/glyph.rs
new file mode 100644
index 000000000..ee20bbf4a
--- /dev/null
+++ b/maplibre/src/sdf/glyph.rs
@@ -0,0 +1,138 @@
+// Except for to-do comments this file was fully translated
+
+use std::collections::{BTreeMap, BTreeSet, HashSet};
+
+use bitflags::bitflags;
+
+use crate::{
+    euclid::Rect,
+    sdf::{
+        bidi::Char16,
+        font_stack::{FontStack, FontStackHash},
+        glyph_range::GlyphRange,
+        TileSpace,
+    },
+};
+
+// TODO structs
+#[derive(Default)]
+struct AlphaImage;
+
+pub type GlyphID = Char16;
+pub type GlyphIDs = BTreeSet<GlyphID>;
+
+// Note: this only works for the BMP
+pub fn getGlyphRange(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;
+    }
+    return start..end;
+}
+
+#[derive(PartialEq, Default, Copy, Clone)]
+pub struct GlyphMetrics {
+    pub width: u32,
+    pub height: u32,
+    pub left: i32,
+    pub top: i32,
+    pub advance: u32,
+}
+
+#[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 borderSize: u8 = 3;
+}
+
+pub type Glyphs = BTreeMap<GlyphID, Option<Glyph>>;
+pub type GlyphMap = BTreeMap<FontStackHash, Glyphs>;
+
+#[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 imageID: Option<String>,
+    // Maps positioned glyph to TaggedString section
+    pub sectionIndex: usize,
+}
+
+#[derive(Default, Clone)]
+pub struct PositionedLine {
+    pub positionedGlyphs: Vec<PositionedGlyph>,
+    pub lineOffset: f64,
+}
+
+#[derive(Clone, Default)]
+pub struct Shaping {
+    pub positionedLines: Vec<PositionedLine>,
+    pub top: f64,
+    pub bottom: f64,
+    pub left: f64,
+    pub right: f64,
+    pub writingMode: WritingModeType,
+
+    pub verticalizable: bool,
+    pub iconsInText: bool,
+}
+impl Shaping {
+    // The y offset *should* be part of the font metadata.
+    pub const yOffset: i32 = -17;
+
+    pub fn new(x: f64, y: f64, writingMode_: WritingModeType) -> Self {
+        Self {
+            positionedLines: vec![],
+            top: y,
+            bottom: y,
+            left: x,
+            right: x,
+            writingMode: writingMode_,
+            verticalizable: false,
+            iconsInText: false,
+        }
+    }
+    pub fn isAnyLineNotEmpty(&self) -> bool {
+        self.positionedLines
+            .iter()
+            .any(|line| !line.positionedGlyphs.is_empty())
+    }
+}
+
+bitflags! {
+    #[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 {
+    fn default() -> Self {
+        WritingModeType::None
+    }
+}
+
+pub type GlyphDependencies = BTreeMap<FontStack, GlyphIDs>;
+pub type GlyphRangeDependencies = BTreeMap<FontStack, HashSet<GlyphRange>>;
diff --git a/maplibre/src/sdf/glyph_atlas.rs b/maplibre/src/sdf/glyph_atlas.rs
new file mode 100644
index 000000000..a21dac343
--- /dev/null
+++ b/maplibre/src/sdf/glyph_atlas.rs
@@ -0,0 +1,31 @@
+use std::collections::BTreeMap;
+
+use crate::{
+    euclid::Rect,
+    sdf::{
+        font_stack::FontStackHash,
+        glyph::{GlyphID, GlyphMap, GlyphMetrics},
+        TileSpace,
+    },
+};
+
+// TODO structs
+pub struct AlphaImage;
+
+#[derive(Clone, Copy, Default)]
+pub struct GlyphPosition {
+    pub rect: Rect<u16, TileSpace>,
+    pub metrics: GlyphMetrics,
+}
+
+pub type GlyphPositionMap = BTreeMap<GlyphID, GlyphPosition>;
+pub type GlyphPositions = BTreeMap<FontStackHash, GlyphPositionMap>;
+
+pub struct GlyphAtlas {
+    pub image: AlphaImage,
+    pub positions: GlyphPositions,
+}
+
+pub fn makeGlyphAtlas(glyphs: &GlyphMap) -> GlyphAtlas {
+    todo!() // Shelfpack library!
+}
diff --git a/maplibre/src/sdf/glyph_range.rs b/maplibre/src/sdf/glyph_range.rs
new file mode 100644
index 000000000..8b3a0ef91
--- /dev/null
+++ b/maplibre/src/sdf/glyph_range.rs
@@ -0,0 +1,14 @@
+use std::ops::Range;
+
+use crate::sdf::util::hash;
+
+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;
+
+fn hash_glyphrange(range: &GlyphRange) -> u64 {
+    hash(&[range.start, range.end])
+}
diff --git a/maplibre/src/sdf/grid_index.rs b/maplibre/src/sdf/grid_index.rs
new file mode 100644
index 000000000..82ac362f6
--- /dev/null
+++ b/maplibre/src/sdf/grid_index.rs
@@ -0,0 +1,546 @@
+use std::{collections::HashSet, f64};
+
+use crate::{
+    euclid::{Box2D, Point2D},
+    sdf::ScreenSpace,
+};
+
+#[derive(Default, Clone, Copy, Debug)]
+pub struct Circle<T> {
+    pub center: Point2D<T, ScreenSpace>,
+    pub radius: T,
+}
+
+impl<T> Circle<T> {
+    pub fn new(center: Point2D<T, ScreenSpace>, radius: T) -> Circle<T> {
+        Self { center, radius }
+    }
+}
+
+impl<T: PartialEq> PartialEq for Circle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.center == other.center && self.radius == other.radius
+    }
+}
+
+impl<T: PartialEq> Eq for Circle<T> {}
+
+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> {
+    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
+    pub fn reserve(&mut self, value: usize) {
+        self.estimated_elements_per_cell = value;
+    }
+
+    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));
+    }
+
+    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));
+    }
+
+    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);
+            return false;
+        });
+        return result;
+    }
+
+    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));
+            return false;
+        });
+        return result;
+    }
+
+    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;
+                    return true;
+                } else {
+                    return false;
+                }
+            } else {
+                hit = true;
+                return true;
+            }
+        });
+        return hit;
+    }
+
+    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;
+                    return true;
+                } else {
+                    return false;
+                }
+            } else {
+                hit = true;
+                return true;
+            }
+        });
+        return hit;
+    }
+
+    pub fn empty(&self) -> bool {
+        return self.box_elements.is_empty() && self.circle_elements.is_empty();
+    }
+}
+
+impl<T: Clone> GridIndex<T> {
+    fn no_intersection(&self, query_box: &Box2D<f64, ScreenSpace>) -> bool {
+        return query_box.max.x < 0.0
+            || query_box.min.x >= self.width
+            || query_box.max.y < 0.0
+            || query_box.min.y >= self.height;
+    }
+
+    fn complete_intersection(&self, query_box: &Box2D<f64, ScreenSpace>) -> bool {
+        return query_box.min.x <= 0.0
+            && query_box.min.y <= 0.0
+            && self.width <= query_box.max.x
+            && self.height <= query_box.max.y;
+    }
+
+    fn convert_to_box(circle: &Circle<f64>) -> Box2D<f64, ScreenSpace> {
+        return 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,
+            ),
+        );
+    }
+
+    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) {
+                            if 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) {
+                            if result_fn(pair.0.clone(), Self::convert_to_box(&bcircle)) {
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    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) {
+                            if 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) {
+                            if result_fn(pair.0.clone(), Self::convert_to_box(&bcircle)) {
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn convert_to_x_cell_coord(&self, x: f64) -> usize {
+        return f64::max(
+            0.0,
+            f64::min((self.x_cell_count - 1) as f64, f64::floor(x * self.x_scale)),
+        ) as usize;
+    }
+
+    fn convert_to_y_cell_coord(&self, y: f64) -> usize {
+        return f64::max(
+            0.0,
+            f64::min((self.y_cell_count - 1) as f64, f64::floor(y * self.y_scale)),
+        ) as usize;
+    }
+
+    fn boxes_collide(first: &Box2D<f64, ScreenSpace>, second: &Box2D<f64, ScreenSpace>) -> bool {
+        return first.min.x <= second.max.x
+            && first.min.y <= second.max.y
+            && first.max.x >= second.min.x
+            && first.max.y >= second.min.y;
+    }
+
+    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;
+        return (both_radii * both_radii) > (dx * dx + dy * dy);
+    }
+
+    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;
+        return (dx * dx + dy * dy) <= (circle.radius * circle.radius);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    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]
+    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]
+        );
+    }
+
+    fn i16_closure() {}
+
+    #[test]
+    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]
+    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]
+    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/sdf/image.rs b/maplibre/src/sdf/image.rs
new file mode 100644
index 000000000..ce6dae14b
--- /dev/null
+++ b/maplibre/src/sdf/image.rs
@@ -0,0 +1,57 @@
+use std::{cmp::Ordering, collections::HashMap};
+
+// TODO
+pub struct ImageManager;
+pub struct PremultipliedImage;
+
+pub type ImageStretch = (f64, f64);
+pub type ImageStretches = Vec<ImageStretch>;
+
+#[derive(Clone)]
+pub struct ImageContent {
+    pub left: f64,
+    pub top: f64,
+    pub right: f64,
+    pub bottom: f64,
+}
+
+pub struct Image {
+    pub id: String,
+
+    image: PremultipliedImage,
+
+    // Pixel ratio of the sprite image.
+    pub pixelRatio: f64,
+
+    // Whether this image should be interpreted as a signed distance field icon.
+    pub sdf: bool,
+
+    // Stretch areas of this image.
+    pub stretchX: Option<ImageStretches>,
+    pub stretchY: Option<ImageStretches>,
+
+    // The space where text can be fit into this image.
+    pub content: Option<ImageContent>,
+}
+
+impl PartialEq<Self> for Image {
+    fn eq(&self, other: &Self) -> bool {
+        self.id.eq(&other.id)
+    }
+}
+
+impl PartialOrd<Self> for Image {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.id.partial_cmp(&other.id)
+    }
+}
+
+pub enum ImageType {
+    Icon,
+    Pattern,
+}
+
+pub type ImageMap = HashMap<String, Image>;
+pub type ImageDependencies = HashMap<String, ImageType>;
+pub type ImageRequestPair = (ImageDependencies, u64);
+pub type ImageVersionMap = HashMap<String, u32>;
diff --git a/maplibre/src/sdf/image_atlas.rs b/maplibre/src/sdf/image_atlas.rs
new file mode 100644
index 000000000..a9d482368
--- /dev/null
+++ b/maplibre/src/sdf/image_atlas.rs
@@ -0,0 +1,80 @@
+use std::collections::HashMap;
+
+use crate::{
+    euclid::Rect,
+    sdf::{
+        image::{
+            Image, ImageContent, ImageManager, ImageMap, ImageStretches, ImageVersionMap,
+            PremultipliedImage,
+        },
+        TileSpace,
+    },
+};
+
+#[derive(Clone)]
+pub struct ImagePosition {
+    pub pixelRatio: f64,
+    pub paddedRect: Rect<u16, TileSpace>,
+    pub version: u32,
+    pub stretchX: ImageStretches,
+    pub stretchY: ImageStretches,
+    pub content: Option<ImageContent>,
+}
+impl ImagePosition {
+    pub const padding: u16 = 1;
+
+    pub fn tl(&self) -> [u16; 2] {
+        return [
+            (self.paddedRect.min().x + Self::padding) as u16,
+            (self.paddedRect.min().y + Self::padding) as u16,
+        ];
+    }
+
+    pub fn br(&self) -> [u16; 2] {
+        return [
+            (self.paddedRect.min().x + self.paddedRect.width() - Self::padding) as u16,
+            (self.paddedRect.min().y + self.paddedRect.height() - Self::padding) as u16,
+        ];
+    }
+
+    pub fn tlbr(&self) -> [u16; 4] {
+        let _tl = self.tl();
+        let _br = self.br();
+        return [_tl[0], _tl[1], _br[0], _br[1]];
+    }
+
+    pub fn displaySize(&self) -> [f64; 2] {
+        return [
+            (self.paddedRect.width() - Self::padding * 2) as f64 / self.pixelRatio,
+            (self.paddedRect.height() - Self::padding * 2) as f64 / self.pixelRatio,
+        ];
+    }
+}
+
+pub type ImagePositions = HashMap<String, ImagePosition>;
+
+struct ImagePatch {
+    image: Image,
+    paddedRect: Rect<u16, TileSpace>,
+}
+
+impl ImagePatch {}
+
+struct ImageAtlas {
+    image: PremultipliedImage,
+    iconPositions: ImagePositions,
+    patternPositions: ImagePositions,
+}
+impl ImageAtlas {
+    pub fn getImagePatchesAndUpdateVersions(image_manager: &ImageManager) -> Vec<ImagePatch> {
+        todo!()
+    }
+}
+
+pub fn makeImageAtlas(
+    image_map_a: &ImageMap,
+    image_map_b: &ImageMap,
+    versionMap: &ImageVersionMap,
+) -> ImageAtlas {
+    todo!()
+}
diff --git a/maplibre/src/sdf/layout/layout.rs b/maplibre/src/sdf/layout/layout.rs
new file mode 100644
index 000000000..92fc9fe0d
--- /dev/null
+++ b/maplibre/src/sdf/layout/layout.rs
@@ -0,0 +1,21 @@
+use std::collections::BTreeSet;
+
+use crate::sdf::{glyph::GlyphDependencies, image::ImageDependencies, MapMode, OverscaledTileID};
+
+#[derive(Clone)]
+pub struct LayerTypeInfo;
+
+#[derive(Clone)]
+pub struct BucketParameters {
+    pub tileID: OverscaledTileID,
+    pub mode: MapMode,
+    pub pixelRatio: f64,
+    pub layerType: LayerTypeInfo,
+}
+
+pub struct LayoutParameters<'a> {
+    pub bucketParameters: &'a mut BucketParameters,
+    pub glyphDependencies: &'a mut GlyphDependencies,
+    pub imageDependencies: &'a mut ImageDependencies,
+    pub availableImages: &'a mut BTreeSet<String>,
+}
diff --git a/maplibre/src/sdf/layout/mod.rs b/maplibre/src/sdf/layout/mod.rs
new file mode 100644
index 000000000..b8c1e0f37
--- /dev/null
+++ b/maplibre/src/sdf/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/sdf/layout/symbol_feature.rs b/maplibre/src/sdf/layout/symbol_feature.rs
new file mode 100644
index 000000000..a56684910
--- /dev/null
+++ b/maplibre/src/sdf/layout/symbol_feature.rs
@@ -0,0 +1,67 @@
+use std::cmp::Ordering;
+
+use crate::sdf::{
+    geometry_tile_data::{FeatureType, GeometryCollection, Identifier, Value},
+    style_types::expression,
+    tagged_string::TaggedString,
+};
+
+// TODO: Actual feature data with properties
+#[derive(Clone)]
+pub struct VectorGeometryTileFeature {
+    pub geometry: GeometryCollection,
+}
+
+#[derive(Clone)]
+pub struct SymbolGeometryTileFeature {
+    feature: Box<VectorGeometryTileFeature>,
+    pub geometry: GeometryCollection, // we need a mutable copy of the geometry for mergeLines()
+    pub formattedText: Option<TaggedString>,
+    pub icon: Option<expression::Image>,
+    pub sortKey: f64,
+    pub index: usize,
+}
+
+impl PartialEq<Self> for SymbolGeometryTileFeature {
+    fn eq(&self, other: &Self) -> bool {
+        self.sortKey.eq(&other.sortKey) // TODO is this correct?
+    }
+}
+
+impl PartialOrd for SymbolGeometryTileFeature {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.sortKey.partial_cmp(&other.sortKey)
+    }
+}
+
+impl SymbolGeometryTileFeature {
+    pub fn getType(&self) -> FeatureType {
+        //  todo!()
+        FeatureType::Point
+    }
+    pub fn getValue(&self, key: &String) -> Option<&Value> {
+        todo!()
+    }
+    pub fn getProperties(&self) -> &serde_json::Value {
+        todo!()
+    }
+    pub fn getID(&self) -> Identifier {
+        todo!()
+    }
+    pub fn getGeometries(&self) -> &GeometryCollection {
+        todo!()
+    }
+}
+
+impl SymbolGeometryTileFeature {
+    pub fn new(feature: Box<VectorGeometryTileFeature>) -> Self {
+        Self {
+            geometry: feature.geometry.clone(), // we need a mutable copy of the geometry for mergeLines()
+            feature: feature,
+            formattedText: None,
+            icon: None,
+            sortKey: 0.0,
+            index: 0,
+        }
+    }
+}
diff --git a/maplibre/src/sdf/layout/symbol_instance.rs b/maplibre/src/sdf/layout/symbol_instance.rs
new file mode 100644
index 000000000..ffe625c9b
--- /dev/null
+++ b/maplibre/src/sdf/layout/symbol_instance.rs
@@ -0,0 +1,450 @@
+use std::rc::Rc;
+
+use bitflags::bitflags;
+use widestring::U16String;
+
+use crate::sdf::{
+    collision_feature::CollisionFeature,
+    geometry::{feature_index::IndexedSubfeature, Anchor},
+    geometry_tile_data::GeometryCoordinates,
+    glyph::{Shaping, WritingModeType},
+    image::ImageMap,
+    quads::{getGlyphQuads, getIconQuads, SymbolQuads},
+    shaping::PositionedIcon,
+    style_types::{SymbolLayoutProperties_Evaluated, SymbolPlacementType},
+};
+
+fn getAnyShaping(shapedTextOrientations: &ShapedTextOrientations) -> &Shaping {
+    if shapedTextOrientations.right().isAnyLineNotEmpty() {
+        return &shapedTextOrientations.right();
+    }
+    if shapedTextOrientations.center.isAnyLineNotEmpty() {
+        return &(shapedTextOrientations.center);
+    }
+    if shapedTextOrientations.left.isAnyLineNotEmpty() {
+        return &(shapedTextOrientations.left);
+    }
+    if shapedTextOrientations.vertical.isAnyLineNotEmpty() {
+        return &(shapedTextOrientations.vertical);
+    }
+    return &shapedTextOrientations.horizontal;
+}
+
+#[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 singleLine: bool,
+}
+
+impl ShapedTextOrientations {
+    pub fn new(
+        horizontal: Shaping,
+        vertical: Shaping,
+        right: Option<Shaping>,
+        center: Shaping,
+        left: Shaping,
+        singleLine: bool,
+    ) -> Self {
+        Self {
+            horizontal: (horizontal),
+            vertical: (vertical),
+            center: (center),
+            left: (left),
+            singleLine,
+        }
+    }
+
+    pub fn horizontal(&self) -> &Shaping {
+        &self.horizontal
+    }
+    pub fn vertical(&self) -> &Shaping {
+        &self.vertical
+    }
+    pub fn right(&self) -> &Shaping {
+        &self.horizontal
+    }
+    pub fn center(&self) -> &Shaping {
+        &self.center
+    }
+    pub fn left(&self) -> &Shaping {
+        &self.left
+    }
+
+    pub fn set_horizontal(&mut self, horizontal: Shaping) {
+        self.horizontal = horizontal;
+    }
+    pub fn set_vertical(&mut self, vertical: Shaping) {
+        self.vertical = vertical;
+    }
+}
+
+bitflags! {
+    #[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;
+    }
+}
+
+#[derive(Default)]
+pub struct SymbolInstanceSharedData {
+    line: GeometryCoordinates,
+    // Note: When singleLine == true, only `rightJustifiedGlyphQuads` is populated.
+    rightJustifiedGlyphQuads: SymbolQuads,
+    centerJustifiedGlyphQuads: SymbolQuads,
+    leftJustifiedGlyphQuads: SymbolQuads,
+    verticalGlyphQuads: SymbolQuads,
+    iconQuads: Option<SymbolQuads>,
+    verticalIconQuads: Option<SymbolQuads>,
+}
+
+impl SymbolInstanceSharedData {
+    pub fn new(
+        line_: GeometryCoordinates,
+        shapedTextOrientations: &ShapedTextOrientations,
+        shapedIcon: Option<PositionedIcon>,
+        verticallyShapedIcon: Option<PositionedIcon>,
+        layout: &SymbolLayoutProperties_Evaluated,
+        textPlacement: SymbolPlacementType,
+        textOffset: [f64; 2],
+        imageMap: &ImageMap,
+        iconRotation: f64,
+        iconType: SymbolContent,
+        hasIconTextFit: bool,
+        allowVerticalPlacement: bool,
+    ) -> Self {
+        let mut self_ = Self {
+            line: line_,
+            ..Self::default()
+        };
+        // Create the quads used for rendering the icon and glyphs.
+        if let Some(shapedIcon) = (&shapedIcon) {
+            self_.iconQuads = Some(getIconQuads(
+                shapedIcon,
+                iconRotation,
+                iconType,
+                hasIconTextFit,
+            ));
+            if let Some(verticallyShapedIcon) = (&verticallyShapedIcon) {
+                self_.verticalIconQuads = Some(getIconQuads(
+                    verticallyShapedIcon,
+                    iconRotation,
+                    iconType,
+                    hasIconTextFit,
+                ));
+            }
+        }
+
+        // todo is this translation correct?
+        if (!shapedTextOrientations.singleLine) {
+            if shapedTextOrientations.right().isAnyLineNotEmpty() {
+                self_.rightJustifiedGlyphQuads = getGlyphQuads(
+                    &shapedTextOrientations.right(),
+                    textOffset,
+                    layout,
+                    textPlacement,
+                    imageMap,
+                    allowVerticalPlacement,
+                );
+            }
+
+            if shapedTextOrientations.center.isAnyLineNotEmpty() {
+                self_.centerJustifiedGlyphQuads = getGlyphQuads(
+                    &shapedTextOrientations.center,
+                    textOffset,
+                    layout,
+                    textPlacement,
+                    imageMap,
+                    allowVerticalPlacement,
+                );
+            }
+
+            if shapedTextOrientations.left.isAnyLineNotEmpty() {
+                self_.leftJustifiedGlyphQuads = getGlyphQuads(
+                    &shapedTextOrientations.left,
+                    textOffset,
+                    layout,
+                    textPlacement,
+                    imageMap,
+                    allowVerticalPlacement,
+                );
+            }
+        } else {
+            let shape = if shapedTextOrientations.right().isAnyLineNotEmpty() {
+                Some(shapedTextOrientations.right())
+            } else {
+                if shapedTextOrientations.center.isAnyLineNotEmpty() {
+                    Some(&shapedTextOrientations.center)
+                } else {
+                    if shapedTextOrientations.left.isAnyLineNotEmpty() {
+                        Some(&shapedTextOrientations.left)
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            if let Some(shape) = shape {
+                self_.rightJustifiedGlyphQuads = getGlyphQuads(
+                    shape,
+                    textOffset,
+                    layout,
+                    textPlacement,
+                    imageMap,
+                    allowVerticalPlacement,
+                );
+            }
+        }
+
+        if shapedTextOrientations.vertical.isAnyLineNotEmpty() {
+            self_.verticalGlyphQuads = getGlyphQuads(
+                &shapedTextOrientations.vertical,
+                textOffset,
+                layout,
+                textPlacement,
+                imageMap,
+                allowVerticalPlacement,
+            );
+        }
+        self_
+    }
+    fn empty(&self) -> bool {
+        return self.rightJustifiedGlyphQuads.is_empty()
+            && self.centerJustifiedGlyphQuads.is_empty()
+            && self.leftJustifiedGlyphQuads.is_empty()
+            && self.verticalGlyphQuads.is_empty();
+    }
+}
+
+#[derive(Clone)]
+pub struct SymbolInstance {
+    sharedData: Rc<SymbolInstanceSharedData>,
+
+    pub anchor: Anchor,
+    pub symbolContent: SymbolContent,
+
+    pub rightJustifiedGlyphQuadsSize: usize,
+    pub centerJustifiedGlyphQuadsSize: usize,
+    pub leftJustifiedGlyphQuadsSize: usize,
+    pub verticalGlyphQuadsSize: usize,
+    pub iconQuadsSize: usize,
+
+    pub textCollisionFeature: CollisionFeature,
+    pub iconCollisionFeature: CollisionFeature,
+    pub verticalTextCollisionFeature: Option<CollisionFeature>,
+    pub verticalIconCollisionFeature: Option<CollisionFeature>,
+    pub writingModes: WritingModeType,
+    pub layoutFeatureIndex: usize, // Index into the set of features included at layout time
+    pub dataFeatureIndex: usize,   // Index into the underlying tile data feature set
+    pub textOffset: [f64; 2],
+    pub iconOffset: [f64; 2],
+    pub key: U16String,
+    pub placedRightTextIndex: Option<usize>,
+    pub placedCenterTextIndex: Option<usize>,
+    pub placedLeftTextIndex: Option<usize>,
+    pub placedVerticalTextIndex: Option<usize>,
+    pub placedIconIndex: Option<usize>,
+    pub placedVerticalIconIndex: Option<usize>,
+    pub textBoxScale: f64,
+    pub variableTextOffset: [f64; 2],
+    pub singleLine: bool,
+    pub crossTileID: u32,
+}
+
+impl SymbolInstance {
+    pub fn new(
+        anchor_: Anchor,
+        sharedData_: Rc<SymbolInstanceSharedData>,
+        shapedTextOrientations: &ShapedTextOrientations,
+        shapedIcon: &Option<PositionedIcon>,
+        verticallyShapedIcon: &Option<PositionedIcon>,
+        textBoxScale_: f64,
+        textPadding: f64,
+        textPlacement: SymbolPlacementType,
+        textOffset_: [f64; 2],
+        iconBoxScale: f64,
+        iconPadding: f64,
+        iconOffset_: [f64; 2],
+        indexedFeature: IndexedSubfeature,
+        layoutFeatureIndex_: usize,
+        dataFeatureIndex_: usize,
+        key_: U16String,
+        overscaling: f64,
+        iconRotation: f64,
+        textRotation: f64,
+        variableTextOffset_: [f64; 2],
+        allowVerticalPlacement: bool,
+        iconType: SymbolContent,
+    ) -> Self {
+        let mut self_ = Self {
+            symbolContent: iconType,
+            // 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
+            textCollisionFeature: CollisionFeature::new_from_text(
+                &sharedData_.line,
+                &anchor_,
+                getAnyShaping(shapedTextOrientations).clone(),
+                textBoxScale_,
+                textPadding,
+                textPlacement,
+                indexedFeature.clone(),
+                overscaling,
+                textRotation,
+            ),
+            iconCollisionFeature: CollisionFeature::new_from_icon(
+                &sharedData_.line,
+                &anchor_,
+                shapedIcon,
+                iconBoxScale,
+                iconPadding,
+                indexedFeature.clone(),
+                iconRotation,
+            ),
+
+            sharedData: sharedData_,
+            anchor: anchor_,
+            writingModes: WritingModeType::None,
+            layoutFeatureIndex: layoutFeatureIndex_,
+            dataFeatureIndex: dataFeatureIndex_,
+            textOffset: textOffset_,
+            iconOffset: iconOffset_,
+            key: key_,
+
+            textBoxScale: textBoxScale_,
+            variableTextOffset: variableTextOffset_,
+            singleLine: shapedTextOrientations.singleLine,
+
+            rightJustifiedGlyphQuadsSize: 0,
+            centerJustifiedGlyphQuadsSize: 0,
+            leftJustifiedGlyphQuadsSize: 0,
+            verticalGlyphQuadsSize: 0,
+            iconQuadsSize: 0,
+
+            verticalTextCollisionFeature: None,
+            placedRightTextIndex: None,
+            placedCenterTextIndex: None,
+            placedLeftTextIndex: None,
+            placedVerticalTextIndex: None,
+            placedIconIndex: None,
+            placedVerticalIconIndex: None,
+
+            verticalIconCollisionFeature: None,
+            crossTileID: 0,
+        };
+
+        // 'hasText' depends on finding at least one glyph in the shaping that's also in the GlyphPositionMap
+        if (!self_.sharedData.empty()) {
+            self_.symbolContent |= SymbolContent::Text;
+        }
+        if (allowVerticalPlacement) {
+            if shapedTextOrientations.vertical.isAnyLineNotEmpty() {
+                let verticalPointLabelAngle = 90.0;
+                self_.verticalTextCollisionFeature = Some(CollisionFeature::new_from_text(
+                    self_.line(),
+                    &self_.anchor,
+                    shapedTextOrientations.vertical.clone(),
+                    textBoxScale_,
+                    textPadding,
+                    textPlacement,
+                    indexedFeature.clone(),
+                    overscaling,
+                    textRotation + verticalPointLabelAngle,
+                ));
+                if (verticallyShapedIcon.is_some()) {
+                    self_.verticalIconCollisionFeature = Some(CollisionFeature::new_from_icon(
+                        &self_.sharedData.line,
+                        &self_.anchor,
+                        verticallyShapedIcon,
+                        iconBoxScale,
+                        iconPadding,
+                        indexedFeature,
+                        iconRotation + verticalPointLabelAngle,
+                    ));
+                }
+            }
+        }
+
+        self_.rightJustifiedGlyphQuadsSize = self_.sharedData.rightJustifiedGlyphQuads.len();
+        self_.centerJustifiedGlyphQuadsSize = self_.sharedData.centerJustifiedGlyphQuads.len();
+        self_.leftJustifiedGlyphQuadsSize = self_.sharedData.leftJustifiedGlyphQuads.len();
+        self_.verticalGlyphQuadsSize = self_.sharedData.verticalGlyphQuads.len();
+
+        self_.iconQuadsSize = if let Some(iconQuads) = &self_.sharedData.iconQuads {
+            iconQuads.len()
+        } else {
+            0
+        };
+
+        if (self_.rightJustifiedGlyphQuadsSize != 0
+            || self_.centerJustifiedGlyphQuadsSize != 0
+            || self_.leftJustifiedGlyphQuadsSize != 0)
+        {
+            self_.writingModes |= WritingModeType::Horizontal;
+        }
+
+        if (self_.verticalGlyphQuadsSize != 0) {
+            self_.writingModes |= WritingModeType::Vertical;
+        }
+
+        self_
+    }
+    pub fn getDefaultHorizontalPlacedTextIndex(&self) -> Option<usize> {
+        if let Some(index) = (self.placedRightTextIndex) {
+            return Some(index);
+        }
+        if let Some(index) = (self.placedCenterTextIndex) {
+            return Some(index);
+        }
+        if let Some(index) = (self.placedLeftTextIndex) {
+            return Some(index);
+        }
+        return None;
+    }
+    pub fn line(&self) -> &GeometryCoordinates {
+        return &self.sharedData.line;
+    }
+    pub fn rightJustifiedGlyphQuads(&self) -> &SymbolQuads {
+        return &self.sharedData.rightJustifiedGlyphQuads;
+    }
+    pub fn leftJustifiedGlyphQuads(&self) -> &SymbolQuads {
+        return &self.sharedData.leftJustifiedGlyphQuads;
+    }
+    pub fn centerJustifiedGlyphQuads(&self) -> &SymbolQuads {
+        return &self.sharedData.centerJustifiedGlyphQuads;
+    }
+    pub fn verticalGlyphQuads(&self) -> &SymbolQuads {
+        return &self.sharedData.verticalGlyphQuads;
+    }
+    pub fn hasText(&self) -> bool {
+        return self.symbolContent.contains(SymbolContent::Text); // TODO Is this correct?
+    }
+    pub fn hasIcon(&self) -> bool {
+        return self.symbolContent.contains(SymbolContent::IconRGBA) || self.hasSdfIcon();
+    }
+    pub fn hasSdfIcon(&self) -> bool {
+        return self.symbolContent.contains(SymbolContent::IconSDF);
+    }
+    pub fn iconQuads(&self) -> &Option<SymbolQuads> {
+        return &self.sharedData.iconQuads;
+    }
+    pub fn verticalIconQuads(&self) -> &Option<SymbolQuads> {
+        return &self.sharedData.verticalIconQuads;
+    }
+    pub fn releaseSharedData(&self) {
+        // todo!()
+        // TODO not sure how to do this self.sharedData.reset();
+    }
+
+    fn invalidCrossTileID() -> u32 {
+        return u32::MAX;
+    }
+}
+
+type SymbolInstanceReferences = Vec<SymbolInstance>;
diff --git a/maplibre/src/sdf/layout/symbol_layout.rs b/maplibre/src/sdf/layout/symbol_layout.rs
new file mode 100644
index 000000000..747eb5d40
--- /dev/null
+++ b/maplibre/src/sdf/layout/symbol_layout.rs
@@ -0,0 +1,1716 @@
+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},
+    sdf::{
+        bidi::{applyArabicShaping, BiDi, Char16},
+        buckets::symbol_bucket::{
+            DynamicVertex, OpacityVertex, PlacedSymbol, Segment, SymbolBucket, SymbolBucketBuffer,
+            SymbolVertex,
+        },
+        geometry::{
+            feature_index::{IndexedSubfeature, RefIndexedSubfeature},
+            Anchor, Anchors,
+        },
+        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::{getAnchorJustification, getShaping, PositionedIcon},
+        style_types::*,
+        tagged_string::{SectionOptions, TaggedString},
+        util::{constants::ONE_EM, i18n, lower_bound, math::deg2radf},
+        CanonicalTileID, MapMode,
+    },
+};
+
+// TODO
+#[derive(Clone, Debug)]
+pub struct SymbolLayer {
+    pub layout: SymbolLayoutProperties_Unevaluated,
+}
+pub type SymbolLayer_Impl = SymbolLayer;
+// TODO
+#[derive(Clone, Debug)]
+pub struct LayerProperties {
+    pub id: String,
+    pub layer: SymbolLayer_Impl,
+}
+pub type SymbolLayerProperties = LayerProperties;
+impl LayerProperties {
+    pub fn layerImpl(&self) -> &SymbolLayer_Impl {
+        // TODO
+        &self.layer
+    }
+
+    pub fn baseImpl(&self) -> &Self {
+        self
+    }
+}
+pub type Bucket = SymbolBucket;
+
+#[derive(Debug)]
+pub struct LayerRenderData {
+    bucket: Rc<Bucket>,
+    layerProperties: LayerProperties,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct SortKeyRange {
+    sortKey: f64,
+    start: usize,
+    end: usize,
+}
+
+impl SortKeyRange {
+    pub fn isFirstRange(&self) -> bool {
+        return self.start == 0;
+    }
+}
+
+// index
+pub struct FeatureIndex;
+
+fn sectionOptionsToValue(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(textColor) = &(options.textColor) {
+        result.insert(
+            expression::kFormattedSectionTextColor.to_string(),
+            expression::Value::Color(textColor.clone()),
+        );
+    }
+    return expression::Value::Object(result);
+}
+
+fn toSymbolLayerProperties(layer: &LayerProperties) -> &SymbolLayerProperties {
+    // TODO
+    //return static_cast<const SymbolLayerProperties&>(*layer);
+    return layer;
+}
+
+fn createLayout(
+    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>());
+    }
+
+    return 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 baselineOffset: 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.
+fn getDefaultHorizontalShaping(shapedTextOrientations: &ShapedTextOrientations) -> &Shaping {
+    if shapedTextOrientations.right().isAnyLineNotEmpty() {
+        return &shapedTextOrientations.right();
+    }
+    if shapedTextOrientations.center().isAnyLineNotEmpty() {
+        return &shapedTextOrientations.center();
+    }
+    if shapedTextOrientations.left().isAnyLineNotEmpty() {
+        return &shapedTextOrientations.left();
+    }
+    return &shapedTextOrientations.horizontal();
+}
+
+fn shapingForTextJustifyType(
+    shapedTextOrientations: &ShapedTextOrientations,
+    type_: TextJustifyType,
+) -> &Shaping {
+    match (type_) {
+        TextJustifyType::Right => {
+            return &shapedTextOrientations.right();
+        }
+
+        TextJustifyType::Left => {
+            return &shapedTextOrientations.left();
+        }
+
+        TextJustifyType::Center => {
+            return &shapedTextOrientations.center();
+        }
+        _ => {
+            assert!(false);
+            return &shapedTextOrientations.horizontal();
+        }
+    }
+}
+
+fn evaluateRadialOffset(anchor: SymbolAnchorType, mut radialOffset: f64) -> [f64; 2] {
+    let mut result = [0.0, 0.0];
+    if (radialOffset < 0.0) {
+        radialOffset = 0.0; // Ignore negative offset.
+    }
+    // solve for r where r^2 + r^2 = radialOffset^2
+    let sqrt2 = 1.41421356237;
+    let hypotenuse = radialOffset / sqrt2;
+
+    match (anchor) {
+        SymbolAnchorType::TopRight | SymbolAnchorType::TopLeft => {
+            result[1] = hypotenuse - baselineOffset;
+        }
+
+        SymbolAnchorType::BottomRight | SymbolAnchorType::BottomLeft => {
+            result[1] = -hypotenuse + baselineOffset;
+        }
+        SymbolAnchorType::Bottom => {
+            result[1] = -radialOffset + baselineOffset;
+        }
+        SymbolAnchorType::Top => {
+            result[1] = radialOffset - baselineOffset;
+        }
+
+        _ => {}
+    }
+
+    match (anchor) {
+        SymbolAnchorType::TopRight | SymbolAnchorType::BottomRight => {
+            result[0] = -hypotenuse;
+        }
+        SymbolAnchorType::TopLeft | SymbolAnchorType::BottomLeft => {
+            result[0] = hypotenuse;
+        }
+        SymbolAnchorType::Left => {
+            result[0] = radialOffset;
+        }
+        SymbolAnchorType::Right => {
+            result[0] = -radialOffset;
+        }
+
+        _ => {}
+    }
+
+    return result;
+}
+
+pub struct SymbolLayout {
+    pub layerPaintProperties: BTreeMap<String, LayerProperties>,
+    pub bucketLeaderID: String,
+    pub symbolInstances: Vec<SymbolInstance>,
+    pub sortKeyRanges: Vec<SortKeyRange>,
+
+    // Stores the layer so that we can hold on to GeometryTileFeature instances
+    // in SymbolFeature, which may reference data from this object.
+    sourceLayer: Box<SymbolGeometryTileLayer>,
+    overscaling: f64,
+    zoom: f64,
+    canonicalID: CanonicalTileID,
+    mode: MapMode,
+    pixelRatio: f64,
+
+    tileSize: u32,
+    tilePixelRatio: f64,
+
+    iconsNeedLinear: bool,
+    sortFeaturesByY: bool,
+    sortFeaturesByKey: bool,
+    allowVerticalPlacement: bool,
+    iconsInText: bool,
+    placementModes: Vec<TextWritingModeType>,
+
+    textSize: <TextSize as DataDrivenLayoutProperty>::UnevaluatedType,
+    iconSize: <IconSize as DataDrivenLayoutProperty>::UnevaluatedType,
+    textRadialOffset: <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
+    compareText: BTreeMap<U16String, Vec<Anchor>>,
+}
+
+impl SymbolLayout {
+    pub fn new(
+        parameters: &BucketParameters,
+        layers: &Vec<LayerProperties>,
+        sourceLayer_: Box<SymbolGeometryTileLayer>,
+        layoutParameters: &mut LayoutParameters, // TODO is this output?
+    ) -> Option<Self> {
+        let overscaling = parameters.tileID.overscaleFactor() as f64;
+        let zoom = parameters.tileID.overscaledZ as f64;
+        let tileSize = (TILE_SIZE * overscaling) as u32;
+
+        let leader: &SymbolLayer_Impl = toSymbolLayerProperties(layers.get(0).unwrap()).layerImpl();
+
+        let mut self_ = Self {
+            bucketLeaderID: layers.first().unwrap().baseImpl().id.clone(),
+
+            sourceLayer: sourceLayer_,
+            overscaling,
+            zoom,
+            canonicalID: parameters.tileID.canonical,
+            mode: parameters.mode,
+            pixelRatio: parameters.pixelRatio,
+            tileSize,
+            tilePixelRatio: EXTENT / tileSize as f64,
+            layout: createLayout(
+                &toSymbolLayerProperties(layers.get(0).unwrap())
+                    .layerImpl()
+                    .layout,
+                zoom,
+            ),
+            textSize: leader.layout.get_dynamic::<TextSize>(),
+            iconSize: leader.layout.get_dynamic::<IconSize>(),
+            textRadialOffset: leader.layout.get_dynamic::<TextRadialOffset>(),
+
+            // default values
+            layerPaintProperties: Default::default(),
+            symbolInstances: vec![],
+            sortKeyRanges: vec![],
+            iconsNeedLinear: false,
+            sortFeaturesByY: false,
+            sortFeaturesByKey: false,
+            allowVerticalPlacement: false,
+            iconsInText: false,
+            placementModes: vec![],
+            features: vec![],
+            bidi: BiDi,
+            compareText: Default::default(),
+        };
+
+        let hasText = self_.layout.has::<TextField>() && self_.layout.has::<TextFont>();
+        let hasIcon = self_.layout.has::<IconImage>();
+
+        if (!hasText && !hasIcon) {
+            return None;
+        }
+
+        let hasSymbolSortKey = !leader.layout.get_dynamic::<SymbolSortKey>().isUndefined();
+        let symbolZOrder = self_.layout.get::<SymbolZOrder>();
+        self_.sortFeaturesByKey = symbolZOrder != SymbolZOrderType::ViewportY && hasSymbolSortKey;
+        let zOrderByViewportY = symbolZOrder == SymbolZOrderType::ViewportY
+            || (symbolZOrder == SymbolZOrderType::Auto && !self_.sortFeaturesByKey);
+        self_.sortFeaturesByY = zOrderByViewportY
+            && (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(|placementMode| {
+                    self_.allowVerticalPlacement = self_.allowVerticalPlacement
+                        || **placementMode == TextWritingModeType::Vertical;
+                    return seen.insert(**placementMode);
+                })
+                .cloned()
+                .collect();
+
+            self_.placementModes = modes;
+        }
+
+        for layer in layers {
+            self_
+                .layerPaintProperties
+                .insert(layer.baseImpl().id.clone(), layer.clone());
+        }
+
+        // Determine glyph dependencies
+        let featureCount = self_.sourceLayer.featureCount();
+        for i in 0..featureCount {
+            let feature = self_.sourceLayer.getFeature(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 (hasText) {
+                let formatted = self_.layout.evaluate4::<TextField>(
+                    self_.zoom,
+                    &ft,
+                    layoutParameters.availableImages,
+                    self_.canonicalID,
+                );
+                let textTransform =
+                    self_
+                        .layout
+                        .evaluate::<TextTransform>(self_.zoom, &ft, self_.canonicalID);
+                let baseFontStack =
+                    self_
+                        .layout
+                        .evaluate::<TextFont>(self_.zoom, &ft, self_.canonicalID);
+
+                ft.formattedText = Some(TaggedString::default());
+                let ft_formattedText = ft.formattedText.as_mut().unwrap();
+                for section in &formatted.sections {
+                    if let Some(image) = (&section.image) {
+                        layoutParameters
+                            .imageDependencies
+                            .insert(image.imageID.clone(), ImageType::Icon);
+                        ft_formattedText.addImageSection(image.imageID.clone());
+                    } else {
+                        let mut u8string = section.text.clone();
+                        if (textTransform == TextTransformType::Uppercase) {
+                            u8string = u8string.to_uppercase();
+                        } else if (textTransform == TextTransformType::Lowercase) {
+                            u8string = u8string.to_lowercase();
+                        }
+
+                        // TODO seems like invalid UTF-8 can not be in a tile? if let Err(e) =
+                        ft_formattedText.addTextSection(
+                            &applyArabicShaping(&U16String::from(u8string.as_str())),
+                            if let Some(fontScale) = section.fontScale {
+                                fontScale
+                            } else {
+                                1.0
+                            },
+                            if let Some(fontStack) = &section.fontStack {
+                                fontStack.clone()
+                            } else {
+                                baseFontStack.clone()
+                            },
+                            section.textColor.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 canVerticalizeText = self_.layout.get::<TextRotationAlignment>()
+                    == AlignmentType::Map
+                    && self_.layout.get::<SymbolPlacement>() != SymbolPlacementType::Point
+                    && ft_formattedText.allowsVerticalWritingMode();
+
+                // Loop through all characters of this text and collect unique codepoints.
+                for j in 0..ft_formattedText.length() {
+                    let section = &formatted.sections[ft_formattedText.getSectionIndex(j) as usize];
+                    if (section.image.is_some()) {
+                        continue;
+                    }
+
+                    let sectionFontStack = &section.fontStack;
+                    let dependencies: &mut GlyphIDs = &mut layoutParameters
+                        .glyphDependencies
+                        .entry(if let Some(sectionFontStack) = sectionFontStack {
+                            sectionFontStack.clone()
+                        } else {
+                            baseFontStack.clone()
+                        })
+                        .or_default(); // TODO this is different in C++, as C++ always creates the default apparently
+                    let codePoint: Char16 = ft_formattedText.getCharCodeAt(j);
+                    dependencies.insert(codePoint);
+                    if (canVerticalizeText
+                        || (self_.allowVerticalPlacement
+                            && ft_formattedText.allowsVerticalWritingMode()))
+                    {
+                        let verticalChr: Char16 = i18n::verticalizePunctuation(codePoint);
+                        if (verticalChr != 0) {
+                            dependencies.insert(verticalChr);
+                        }
+                    }
+                }
+            }
+
+            if (hasIcon) {
+                ft.icon = Some(self_.layout.evaluate4::<IconImage>(
+                    self_.zoom,
+                    &ft,
+                    layoutParameters.availableImages,
+                    self_.canonicalID,
+                )); // TODO it might be that this is None?
+                layoutParameters
+                    .imageDependencies
+                    .insert(ft.icon.as_ref().unwrap().imageID.clone(), ImageType::Icon);
+            }
+
+            if (ft.formattedText.is_some() || ft.icon.is_some()) {
+                if (self_.sortFeaturesByKey) {
+                    ft.sortKey =
+                        self_
+                            .layout
+                            .evaluate::<SymbolSortKey>(self_.zoom, &ft, self_.canonicalID);
+
+                    let lowerBound = lower_bound(&self_.features, &ft);
+                    self_.features.insert(lowerBound, ft);
+                } else {
+                    self_.features.push(ft);
+                }
+            }
+        }
+
+        if (self_.layout.get::<SymbolPlacement>() == SymbolPlacementType::Line) {
+            todo!()
+            // TODO mergeLines(self_.features);
+        }
+
+        Some(self_)
+    }
+    pub fn prepareSymbols(
+        &mut self,
+        glyphMap: &GlyphMap,
+        glyphPositions: &GlyphPositions,
+        imageMap: &ImageMap,
+        imagePositions: &ImagePositions,
+    ) {
+        let isPointPlacement: bool =
+            self.layout.get::<SymbolPlacement>() == SymbolPlacementType::Point;
+        let textAlongLine: bool =
+            self.layout.get::<TextRotationAlignment>() == AlignmentType::Map && !isPointPlacement;
+
+        let mut toProcessFeatures = Vec::new();
+
+        for (feature_index, feature) in self.features.iter_mut().enumerate() {
+            // TODO expensive clone
+            if (feature.geometry.is_empty()) {
+                continue;
+            }
+
+            let mut shapedTextOrientations: ShapedTextOrientations =
+                ShapedTextOrientations::default();
+            let mut shapedIcon: Option<PositionedIcon> = None;
+            let mut textOffset = [0.0, 0.0];
+            let layoutTextSize: f64 =
+                self.layout
+                    .evaluate::<TextSize>(self.zoom + 1., feature, self.canonicalID);
+            let layoutTextSizeAtBucketZoomLevel: f64 =
+                self.layout
+                    .evaluate::<TextSize>(self.zoom, feature, self.canonicalID);
+            let layoutIconSize: f64 =
+                self.layout
+                    .evaluate::<IconSize>(self.zoom + 1., feature, self.canonicalID);
+
+            // if feature has text, shape the text
+            if let Some(mut feature_formattedText) = feature.formattedText.clone() {
+                if (layoutTextSize > 0.0) {
+                    let lineHeight: f64 = self.layout.get::<TextLineHeight>() * ONE_EM;
+                    let spacing: f64 = if i18n::allowsLetterSpacing(feature_formattedText.rawText())
+                    {
+                        self.layout.evaluate::<TextLetterSpacing>(
+                            self.zoom,
+                            feature,
+                            self.canonicalID,
+                        ) * ONE_EM
+                    } else {
+                        0.0
+                    };
+
+                    let mut applyShaping = |formattedText: &TaggedString,
+                                            writingMode: WritingModeType,
+                                            textAnchor: SymbolAnchorType,
+                                            textJustify: TextJustifyType,
+                                            textOffset: &[f64; 2]|
+                     -> Shaping {
+                        let result = getShaping(
+                            /* string */ formattedText,
+                            /* maxWidth: ems */
+                            if isPointPlacement {
+                                self.layout.evaluate::<TextMaxWidth>(
+                                    self.zoom,
+                                    feature,
+                                    self.canonicalID,
+                                ) * ONE_EM
+                            } else {
+                                0.0
+                            },
+                            /* ems */ lineHeight,
+                            textAnchor,
+                            textJustify,
+                            /* ems */ spacing,
+                            /* translate */ textOffset,
+                            /* writingMode */ writingMode,
+                            /* bidirectional algorithm object */ &self.bidi,
+                            glyphMap,
+                            /* glyphs */ glyphPositions,
+                            /* images */ imagePositions,
+                            layoutTextSize,
+                            layoutTextSizeAtBucketZoomLevel,
+                            self.allowVerticalPlacement,
+                        );
+
+                        return result;
+                    };
+
+                    let variableTextAnchor: Vec<TextVariableAnchorType> =
+                        self.layout.evaluate_static::<TextVariableAnchor>(
+                            self.zoom,
+                            feature,
+                            self.canonicalID,
+                        );
+                    let textAnchor: SymbolAnchorType =
+                        self.layout
+                            .evaluate::<TextAnchor>(self.zoom, feature, self.canonicalID);
+                    if (variableTextAnchor.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 radialOffset: f64 = self.layout.evaluate::<TextRadialOffset>(
+                            self.zoom,
+                            feature,
+                            self.canonicalID,
+                        );
+                        if (radialOffset > 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.
+                            textOffset = evaluateRadialOffset(textAnchor, radialOffset * ONE_EM);
+                        } else {
+                            textOffset = [
+                                self.layout.evaluate::<TextOffset>(
+                                    self.zoom,
+                                    feature,
+                                    self.canonicalID,
+                                )[0] * ONE_EM,
+                                self.layout.evaluate::<TextOffset>(
+                                    self.zoom,
+                                    feature,
+                                    self.canonicalID,
+                                )[1] * ONE_EM,
+                            ];
+                        }
+                    }
+                    let mut textJustify = if textAlongLine {
+                        TextJustifyType::Center
+                    } else {
+                        self.layout
+                            .evaluate::<TextJustify>(self.zoom, feature, self.canonicalID)
+                    };
+
+                    let mut addVerticalShapingForPointLabelIfNeeded =
+                        |shapedTextOrientations: &mut ShapedTextOrientations,
+                         feature_formattedText: &mut TaggedString| {
+                            if (self.allowVerticalPlacement
+                                && feature_formattedText.allowsVerticalWritingMode())
+                            {
+                                feature_formattedText.verticalizePunctuation();
+                                // 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.
+                                shapedTextOrientations.set_vertical(applyShaping(
+                                    &feature_formattedText,
+                                    WritingModeType::Vertical,
+                                    textAnchor,
+                                    TextJustifyType::Left,
+                                    &textOffset,
+                                ))
+                            }
+                        };
+
+                    // If this layer uses text-variable-anchor, generate shapings for
+                    // all justification possibilities.
+                    if (!textAlongLine && !variableTextAnchor.is_empty()) {
+                        let mut justifications: Vec<TextJustifyType> = Vec::new();
+                        if (textJustify != TextJustifyType::Auto) {
+                            justifications.push(textJustify);
+                        } else {
+                            for anchor in &variableTextAnchor {
+                                justifications.push(getAnchorJustification(anchor));
+                            }
+                        }
+                        for justification in justifications {
+                            let mut shapingForJustification =
+                                shapingForTextJustifyType(&shapedTextOrientations, justification);
+                            if (shapingForJustification.isAnyLineNotEmpty()) {
+                                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 = applyShaping(
+                                &feature_formattedText,
+                                WritingModeType::Horizontal,
+                                SymbolAnchorType::Center,
+                                justification,
+                                &textOffset,
+                            );
+                            if (shaping.isAnyLineNotEmpty()) {
+                                shapingForJustification = &shaping;
+                                if (shapingForJustification.positionedLines.len() == 1) {
+                                    shapedTextOrientations.singleLine = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        // Vertical point label shaping if allowVerticalPlacement is enabled.
+                        addVerticalShapingForPointLabelIfNeeded(
+                            &mut shapedTextOrientations,
+                            &mut feature_formattedText,
+                        );
+                    } else {
+                        if (textJustify == TextJustifyType::Auto) {
+                            textJustify = getAnchorJustification(&textAnchor);
+                        }
+
+                        // Horizontal point or line label.
+                        let shaping = applyShaping(
+                            &feature_formattedText,
+                            WritingModeType::Horizontal,
+                            textAnchor,
+                            textJustify,
+                            &textOffset,
+                        );
+                        if (shaping.isAnyLineNotEmpty()) {
+                            shapedTextOrientations.set_horizontal(shaping)
+                        }
+
+                        // Vertical point label shaping if allowVerticalPlacement is enabled.
+                        addVerticalShapingForPointLabelIfNeeded(
+                            &mut shapedTextOrientations,
+                            &mut feature_formattedText,
+                        );
+
+                        // Verticalized line label.
+                        if (textAlongLine && feature_formattedText.allowsVerticalWritingMode()) {
+                            feature_formattedText.verticalizePunctuation();
+                            shapedTextOrientations.set_vertical(applyShaping(
+                                &feature_formattedText,
+                                WritingModeType::Vertical,
+                                textAnchor,
+                                textJustify,
+                                &textOffset,
+                            ));
+                        }
+                    }
+                }
+
+                feature.formattedText = Some(feature_formattedText);
+            }
+
+            // if feature has icon, get sprite atlas position
+            let mut iconType: SymbolContent = SymbolContent::None;
+            if let Some(icon) = &feature.icon {
+                let image = imageMap.get(&icon.imageID);
+                if let Some(image) = image {
+                    iconType = SymbolContent::IconRGBA;
+                    shapedIcon = Some(PositionedIcon::shapeIcon(
+                        imagePositions.get(&icon.imageID).unwrap().clone(),
+                        &self
+                            .layout
+                            .evaluate::<IconOffset>(self.zoom, feature, self.canonicalID),
+                        self.layout
+                            .evaluate::<IconAnchor>(self.zoom, feature, self.canonicalID),
+                    ));
+                    if (image.sdf) {
+                        iconType = SymbolContent::IconSDF;
+                    }
+                    if (image.pixelRatio != self.pixelRatio) {
+                        self.iconsNeedLinear = true;
+                    } else if (self.layout.get_dynamic::<IconRotate>().constantOr(1.0) != 0.0) {
+                        self.iconsNeedLinear = true;
+                    }
+                }
+            }
+
+            // if either shapedText or icon position is present, add the feature
+            let defaultShaping = getDefaultHorizontalShaping(&shapedTextOrientations);
+            self.iconsInText = if defaultShaping.isAnyLineNotEmpty() {
+                defaultShaping.iconsInText
+            } else {
+                false
+            };
+            if (defaultShaping.isAnyLineNotEmpty() || shapedIcon.is_some()) {
+                // TODO borrow conflict with self.features
+                toProcessFeatures.push((
+                    feature_index,
+                    shapedTextOrientations,
+                    shapedIcon,
+                    imageMap.clone(),
+                    textOffset,
+                    layoutTextSize,
+                    layoutIconSize,
+                    iconType,
+                ));
+            }
+        }
+
+        for (
+            feature_index,
+            shapedTextOrientations,
+            shapedIcon,
+            imageMap,
+            textOffset,
+            layoutTextSize,
+            layoutIconSize,
+            iconType,
+        ) in toProcessFeatures
+        {
+            self.addFeature(
+                feature_index,
+                &self.features[feature_index].clone(), // TODO likely wrong clone
+                &shapedTextOrientations,
+                shapedIcon,
+                imageMap,
+                textOffset,
+                layoutTextSize,
+                layoutIconSize,
+                iconType,
+            );
+
+            self.features[feature_index].geometry.clear();
+        }
+
+        self.compareText.clear();
+    }
+
+    pub fn createBucket(
+        &self,
+        _imagePositions: ImagePositions,
+        _feature_index: Box<FeatureIndex>,
+        renderData: &mut HashMap<String, LayerRenderData>,
+        firstLoad: bool,
+        showCollisionBoxes: bool,
+        canonical: &CanonicalTileID,
+    ) {
+        let mut symbolInstances = self.symbolInstances.clone(); // TODO should we clone or modify the symbol instances?
+        let mut bucket: SymbolBucket = SymbolBucket::new(
+            self.layout.clone(),
+            &self.layerPaintProperties,
+            &self.textSize,
+            &self.iconSize,
+            self.zoom,
+            self.iconsNeedLinear,
+            self.sortFeaturesByY,
+            self.bucketLeaderID.clone(),
+            self.symbolInstances.clone(), // TODO should we clone or modify the symbol instances?
+            self.sortKeyRanges.clone(),
+            self.tilePixelRatio,
+            self.allowVerticalPlacement,
+            self.placementModes.clone(),
+            self.iconsInText,
+        );
+
+        for symbolInstance in &mut symbolInstances {
+            let hasText = symbolInstance.hasText();
+            let hasIcon = symbolInstance.hasIcon();
+            let singleLine = symbolInstance.singleLine;
+
+            let feature = self
+                .features
+                .get(symbolInstance.layoutFeatureIndex)
+                .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 (hasIcon) {
+                let sizeData: Range<f64> = bucket.iconSizeBinder.getVertexSizeData(feature); // TODO verify usage of range
+                let iconBuffer = if symbolInstance.hasSdfIcon() {
+                    &mut bucket.sdfIcon
+                } else {
+                    &mut bucket.icon
+                };
+                let mut placeIcon =
+                    |iconQuads: &SymbolQuads, mut index: usize, writingMode: WritingModeType| {
+                        let mut iconSymbol = PlacedSymbol {
+                            anchorPoint: symbolInstance.anchor.point,
+                            segment: symbolInstance.anchor.segment.unwrap_or(0),
+                            lowerSize: sizeData.start,
+                            upperSize: sizeData.end,
+                            lineOffset: symbolInstance.iconOffset,
+                            writingModes: writingMode,
+                            line: symbolInstance.line().clone(),
+                            tileDistances: Vec::new(),
+                            glyphOffsets: vec![],
+                            hidden: false,
+                            vertexStartIndex: 0,
+                            crossTileID: 0,
+                            placedOrientation: None,
+                            angle: if (self.allowVerticalPlacement
+                                && writingMode == WritingModeType::Vertical)
+                            {
+                                PI / 2.
+                            } else {
+                                0.0
+                            },
+                            placedIconIndex: None,
+                        };
+
+                        iconSymbol.vertexStartIndex = self.addSymbols(
+                            iconBuffer,
+                            sizeData.clone(),
+                            iconQuads,
+                            &symbolInstance.anchor,
+                            &mut iconSymbol,
+                            feature.sortKey,
+                        );
+
+                        iconBuffer.placedSymbols.push(iconSymbol);
+                        index = iconBuffer.placedSymbols.len() - 1; // TODO we receive an index but always overwrite it
+                    };
+
+                placeIcon(
+                    symbolInstance.iconQuads().as_ref().unwrap(),
+                    symbolInstance.placedIconIndex.unwrap(),
+                    WritingModeType::None,
+                );
+                if let Some(verticalIconQuads) = (symbolInstance.verticalIconQuads()) {
+                    placeIcon(
+                        verticalIconQuads,
+                        symbolInstance.placedVerticalIconIndex.unwrap(),
+                        WritingModeType::Vertical,
+                    );
+                }
+
+                // TODO
+                assert!(bucket.paintProperties.is_empty())
+                //for pair in bucket.paintProperties {
+                //    pair.1.iconBinders.populateVertexVectors(
+                //        feature,
+                //        iconBuffer.sharedVertices.elements(),
+                //        symbolInstance.dataFeatureIndex,
+                //        {},
+                //        {},
+                //        canonical,
+                //    );
+                //}
+            }
+
+            if (hasText && feature.formattedText.is_some()) {
+                let mut lastAddedSection: Option<usize> = None;
+                if (singleLine) {
+                    let mut placedTextIndex: Option<usize> = None;
+                    let (newLastAddedSection, newPlacedIndex) = self.addSymbolGlyphQuads(
+                        &mut bucket,
+                        symbolInstance,
+                        feature,
+                        symbolInstance.writingModes,
+                        placedTextIndex,
+                        symbolInstance.rightJustifiedGlyphQuads(),
+                        canonical,
+                        lastAddedSection,
+                    );
+                    lastAddedSection = Some(newLastAddedSection);
+                    placedTextIndex = newPlacedIndex;
+                    symbolInstance.placedRightTextIndex = placedTextIndex;
+                    symbolInstance.placedCenterTextIndex = placedTextIndex;
+                    symbolInstance.placedLeftTextIndex = placedTextIndex;
+                } else {
+                    if (symbolInstance.rightJustifiedGlyphQuadsSize != 0) {
+                        let (newLastAddedSection, newPlacedIndex) = self.addSymbolGlyphQuads(
+                            &mut bucket,
+                            symbolInstance,
+                            feature,
+                            symbolInstance.writingModes,
+                            symbolInstance.placedRightTextIndex,
+                            symbolInstance.rightJustifiedGlyphQuads(),
+                            canonical,
+                            lastAddedSection,
+                        );
+                        lastAddedSection = Some(newLastAddedSection);
+                        symbolInstance.placedRightTextIndex = newPlacedIndex
+                    }
+                    if (symbolInstance.centerJustifiedGlyphQuadsSize != 0) {
+                        let (newLastAddedSection, newPlacedIndex) = self.addSymbolGlyphQuads(
+                            &mut bucket,
+                            symbolInstance,
+                            feature,
+                            symbolInstance.writingModes,
+                            symbolInstance.placedCenterTextIndex,
+                            symbolInstance.centerJustifiedGlyphQuads(),
+                            canonical,
+                            lastAddedSection,
+                        );
+                        lastAddedSection = Some(newLastAddedSection);
+                        symbolInstance.placedCenterTextIndex = newPlacedIndex
+                    }
+                    if (symbolInstance.leftJustifiedGlyphQuadsSize != 0) {
+                        let (newLastAddedSection, newPlacedIndex) = self.addSymbolGlyphQuads(
+                            &mut bucket,
+                            symbolInstance,
+                            feature,
+                            symbolInstance.writingModes,
+                            symbolInstance.placedLeftTextIndex,
+                            symbolInstance.leftJustifiedGlyphQuads(),
+                            canonical,
+                            lastAddedSection,
+                        );
+                        lastAddedSection = Some(newLastAddedSection);
+                        symbolInstance.placedLeftTextIndex = newPlacedIndex
+                    }
+                }
+                if (symbolInstance.writingModes.contains(WritingModeType::Vertical) // TODO is bitset op correct?
+                    && symbolInstance.verticalGlyphQuadsSize != 0)
+                {
+                    let (newLastAddedSection, newPlacedIndex) = self.addSymbolGlyphQuads(
+                        &mut bucket,
+                        symbolInstance,
+                        feature,
+                        WritingModeType::Vertical,
+                        symbolInstance.placedVerticalTextIndex,
+                        symbolInstance.verticalGlyphQuads(),
+                        canonical,
+                        lastAddedSection,
+                    );
+                    lastAddedSection = Some(newLastAddedSection);
+                    symbolInstance.placedVerticalTextIndex = newPlacedIndex
+                }
+                assert!(lastAddedSection.is_some()); // True, as hasText == true;
+                self.updatePaintPropertiesForSection(
+                    &mut bucket,
+                    feature,
+                    lastAddedSection.unwrap(),
+                    canonical,
+                );
+            }
+
+            symbolInstance.releaseSharedData();
+        }
+
+        if (showCollisionBoxes) {
+            self.addToDebugBuffers(&mut bucket);
+        }
+        if (bucket.hasData()) {
+            for pair in &self.layerPaintProperties {
+                if (!firstLoad) {
+                    bucket.justReloaded = true;
+                }
+                renderData.insert(
+                    pair.0.clone(),
+                    LayerRenderData {
+                        bucket: Rc::new(bucket.clone()), // TODO is cloning intended here?
+                        layerProperties: pair.1.clone(),
+                    },
+                );
+            }
+        }
+    }
+
+    fn hasSymbolInstances(&self) -> bool {
+        return !self.symbolInstances.is_empty();
+    }
+    fn hasDependencies(&self) -> bool {
+        return !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.
+     */
+    pub fn evaluateVariableOffset(anchor: SymbolAnchorType, mut offset: [f64; 2]) -> [f64; 2] {
+        if (offset[1] == Self::INVALID_OFFSET_VALUE) {
+            return evaluateRadialOffset(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] - baselineOffset;
+            }
+
+            SymbolAnchorType::BottomRight
+            | SymbolAnchorType::BottomLeft
+            | SymbolAnchorType::Bottom => {
+                result[1] = -offset[1] + baselineOffset;
+            }
+
+            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 => {}
+        }
+
+        return 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.
+    pub fn calculateTileDistances(line: &GeometryCoordinates, anchor: &Anchor) -> Vec<f64> {
+        let mut tileDistances: Vec<f64> = vec![0.0; line.len()];
+        if let Some(segment) = (anchor.segment) {
+            assert!(segment < line.len());
+            let mut sumForwardLength = if (segment + 1 < line.len()) {
+                anchor.point.distance_to(line[segment + 1].cast::<f64>())
+            } else {
+                0.0
+            };
+            let mut sumBackwardLength = anchor.point.distance_to(line[segment].cast::<f64>());
+            for i in segment + 1..line.len() {
+                tileDistances[i] = sumForwardLength;
+                if (i < line.len() - 1) {
+                    sumForwardLength +=
+                        line[i + 1].cast::<f64>().distance_to(line[i].cast::<f64>());
+                }
+            }
+
+            let mut i = segment;
+            loop {
+                tileDistances[i] = sumBackwardLength;
+                if (i != 0) {
+                    sumBackwardLength +=
+                        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;
+            }
+        }
+        return tileDistances;
+    }
+}
+
+impl SymbolLayout {
+    fn addFeature(
+        &mut self,
+        layoutFeatureIndex: usize,
+        feature: &SymbolGeometryTileFeature,
+        shapedTextOrientations: &ShapedTextOrientations,
+        mut shapedIcon: Option<PositionedIcon>, // TODO should this be an output?
+        imageMap: &ImageMap,
+        textOffset: [f64; 2],
+        layoutTextSize: f64,
+        layoutIconSize: f64,
+        iconType: SymbolContent,
+    ) {
+        let minScale = 0.5;
+        let glyphSize = 24.0;
+
+        let iconOffset: [f64; 2] =
+            self.layout
+                .evaluate::<IconOffset>(self.zoom, feature, self.canonicalID);
+
+        // 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 textMaxSize = self
+            .layout
+            .evaluate::<TextSize>(18., feature, self.canonicalID);
+
+        let fontScale = layoutTextSize / glyphSize;
+        let textBoxScale = self.tilePixelRatio * fontScale;
+        let textMaxBoxScale = self.tilePixelRatio * textMaxSize / glyphSize;
+        let iconBoxScale = self.tilePixelRatio * layoutIconSize;
+        let symbolSpacing = self.tilePixelRatio * self.layout.get::<SymbolSpacing>();
+        let textPadding = self.layout.get::<TextPadding>() * self.tilePixelRatio;
+        let iconPadding = self.layout.get::<IconPadding>() * self.tilePixelRatio;
+        let textMaxAngle = deg2radf(self.layout.get::<TextMaxAngle>());
+        let iconRotation = self
+            .layout
+            .evaluate::<IconRotate>(self.zoom, feature, self.canonicalID);
+        let textRotation = self
+            .layout
+            .evaluate::<TextRotate>(self.zoom, feature, self.canonicalID);
+        let variableTextOffset: [f64; 2];
+        if (!self.textRadialOffset.isUndefined()) {
+            variableTextOffset = [
+                self.layout
+                    .evaluate::<TextRadialOffset>(self.zoom, feature, self.canonicalID)
+                    * ONE_EM,
+                Self::INVALID_OFFSET_VALUE,
+            ];
+        } else {
+            variableTextOffset = [
+                self.layout
+                    .evaluate::<TextOffset>(self.zoom, feature, self.canonicalID)[0]
+                    * ONE_EM,
+                self.layout
+                    .evaluate::<TextOffset>(self.zoom, feature, self.canonicalID)[1]
+                    * ONE_EM,
+            ];
+        }
+
+        let textPlacement: SymbolPlacementType =
+            if self.layout.get::<TextRotationAlignment>() != AlignmentType::Map {
+                SymbolPlacementType::Point
+            } else {
+                self.layout.get::<SymbolPlacement>()
+            };
+
+        let textRepeatDistance: f64 = symbolSpacing / 2.;
+        let evaluatedLayoutProperties: SymbolLayoutProperties_Evaluated =
+            self.layout.evaluate_feature(self.zoom, feature);
+        let indexedFeature = IndexedSubfeature {
+            ref_: RefIndexedSubfeature {
+                index: feature.index,
+                sortIndex: self.symbolInstances.len(),
+                sourceLayerName: self.sourceLayer.getName().to_string(),
+                bucketLeaderID: self.bucketLeaderID.clone(),
+                bucketInstanceId: 0,
+                collisionGroupId: 0,
+            },
+            sourceLayerNameCopy: self.sourceLayer.getName().to_string(),
+            bucketLeaderIDCopy: self.bucketLeaderID.clone(),
+        };
+
+        let iconTextFit = evaluatedLayoutProperties.get::<IconTextFit>();
+        let hasIconTextFit = iconTextFit != IconTextFitType::None;
+        // Adjust shaped icon size when icon-text-fit is used.
+        let mut verticallyShapedIcon: Option<PositionedIcon> = None;
+
+        if let Some(shapedIcon) = &mut shapedIcon {
+            if (hasIconTextFit) {
+                // Create vertically shaped icon for vertical writing mode if needed.
+                if (self.allowVerticalPlacement
+                    && shapedTextOrientations.vertical().isAnyLineNotEmpty())
+                {
+                    verticallyShapedIcon = Some(shapedIcon.clone());
+                    verticallyShapedIcon.as_mut().unwrap().fitIconToText(
+                        &shapedTextOrientations.vertical(),
+                        iconTextFit,
+                        &self.layout.get::<IconTextFitPadding>(),
+                        &iconOffset,
+                        fontScale,
+                    );
+                }
+                let shapedText = getDefaultHorizontalShaping(shapedTextOrientations);
+                if (shapedText.isAnyLineNotEmpty()) {
+                    shapedIcon.fitIconToText(
+                        shapedText,
+                        iconTextFit,
+                        &self.layout.get::<IconTextFitPadding>(),
+                        &iconOffset,
+                        fontScale,
+                    );
+                }
+            }
+        }
+
+        let mut addSymbolInstance = |anchor: &Anchor, sharedData: Rc<SymbolInstanceSharedData>| {
+            // assert!(sharedData); TODO
+            let anchorInsideTile = anchor.point.x >= 0.
+                && anchor.point.x < EXTENT
+                && anchor.point.y >= 0.
+                && anchor.point.y < EXTENT;
+
+            if (self.mode == MapMode::Tile || anchorInsideTile) {
+                // 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.symbolInstances.push(SymbolInstance::new(
+                    anchor.clone(),
+                    sharedData,
+                    shapedTextOrientations,
+                    &shapedIcon,
+                    &verticallyShapedIcon,
+                    textBoxScale,
+                    textPadding,
+                    textPlacement,
+                    textOffset,
+                    iconBoxScale,
+                    iconPadding,
+                    iconOffset,
+                    indexedFeature.clone(),
+                    layoutFeatureIndex,
+                    feature.index,
+                    if let Some(formattedText) = &feature.formattedText {
+                        formattedText.rawText().clone()
+                    } else {
+                        U16String::new()
+                    },
+                    self.overscaling,
+                    iconRotation,
+                    textRotation,
+                    variableTextOffset,
+                    self.allowVerticalPlacement,
+                    iconType,
+                ));
+
+                if (self.sortFeaturesByKey) {
+                    if (!self.sortKeyRanges.is_empty()
+                        && self.sortKeyRanges.last().unwrap().sortKey == feature.sortKey)
+                    {
+                        self.sortKeyRanges.last_mut().unwrap().end = self.symbolInstances.len();
+                    } else {
+                        self.sortKeyRanges.push(SortKeyRange {
+                            sortKey: feature.sortKey,
+                            start: self.symbolInstances.len() - 1,
+                            end: self.symbolInstances.len(),
+                        });
+                    }
+                }
+            }
+        };
+
+        let createSymbolInstanceSharedData = |line: GeometryCoordinates| {
+            return Rc::new(SymbolInstanceSharedData::new(
+                line,
+                shapedTextOrientations,
+                shapedIcon.clone(),
+                verticallyShapedIcon.clone(),
+                &evaluatedLayoutProperties,
+                textPlacement,
+                textOffset,
+                imageMap,
+                iconRotation,
+                iconType,
+                hasIconTextFit,
+                self.allowVerticalPlacement,
+            ));
+        };
+
+        let type_ = feature.getType();
+
+        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((minScale) as usize),
+                };
+                addSymbolInstance(&anchor, createSymbolInstanceSharedData(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((minScale) as usize),
+                    };
+                    addSymbolInstance(
+                        &anchor,
+                        createSymbolInstanceSharedData(GeometryCoordinates(vec![*point])),
+                    );
+                }
+            }
+        }
+    }
+
+    fn anchorIsTooClose(&mut self, text: &U16String, repeatDistance: f64, anchor: &Anchor) -> bool {
+        if let Some(otherAnchors) = self.compareText.get(text) {
+            for otherAnchor in otherAnchors {
+                if (anchor.point.distance_to(otherAnchor.point) < repeatDistance) {
+                    return true;
+                }
+            }
+        } else {
+            self.compareText.insert(text.clone(), Anchors::new());
+        }
+
+        let anchors = self.compareText.get_mut(text).unwrap();
+        anchors.push(anchor.clone());
+        return false;
+    }
+
+    fn addToDebugBuffers(&self, bucket: &mut SymbolBucket) {
+        todo!()
+    }
+
+    // Adds placed items to the buffer.
+    fn addSymbol(
+        &self,
+        buffer: &mut SymbolBucketBuffer,
+        sizeData: Range<f64>,
+        symbol: &SymbolQuad,
+        labelAnchor: &Anchor,
+        sortKey: f64,
+    ) -> usize {
+        let vertexLength: u16 = 4;
+
+        let tl = symbol.tl;
+        let tr = symbol.tr;
+        let bl = symbol.bl;
+        let br = symbol.br;
+        let tex = symbol.tex;
+        let pixelOffsetTL = symbol.pixelOffsetTL;
+        let pixelOffsetBR = symbol.pixelOffsetBR;
+        let minFontScale = symbol.minFontScale;
+
+        if (buffer.segments.is_empty()
+            || buffer.segments.last().unwrap().vertexLength + vertexLength as usize
+                > u16::MAX as usize
+            || (buffer.segments.last().unwrap().sortKey - sortKey).abs() > f64::EPSILON)
+        {
+            buffer.segments.push(Segment {
+                vertexOffset: buffer.sharedVertices.len(),
+                indexOffset: buffer.triangles.len(),
+                vertexLength: 0,
+                indexLength: 0,
+                sortKey,
+                _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.vertexLength <= u16::MAX as usize);
+        let index = (segment.vertexLength) as u16;
+
+        // coordinates (2 triangles)
+        let vertices = &mut buffer.sharedVertices;
+        vertices.push(SymbolVertex::new(
+            labelAnchor.point,
+            tl,
+            symbol.glyphOffset.y,
+            tex.origin.x,
+            tex.origin.y,
+            sizeData.clone(),
+            symbol.isSDF,
+            pixelOffsetTL,
+            minFontScale,
+        ));
+        vertices.push(SymbolVertex::new(
+            labelAnchor.point,
+            tr,
+            symbol.glyphOffset.y,
+            tex.origin.x + tex.width(),
+            tex.origin.y,
+            sizeData.clone(),
+            symbol.isSDF,
+            Point2D::new(pixelOffsetBR.x, pixelOffsetTL.y),
+            minFontScale,
+        ));
+        vertices.push(SymbolVertex::new(
+            labelAnchor.point,
+            bl,
+            symbol.glyphOffset.y,
+            tex.origin.x,
+            tex.origin.y + tex.height(),
+            sizeData.clone(),
+            symbol.isSDF,
+            Point2D::new(pixelOffsetTL.x, pixelOffsetBR.y),
+            minFontScale,
+        ));
+        vertices.push(SymbolVertex::new(
+            labelAnchor.point,
+            br,
+            symbol.glyphOffset.y,
+            tex.origin.x + tex.width(),
+            tex.origin.y + tex.height(),
+            sizeData.clone(),
+            symbol.isSDF,
+            pixelOffsetBR,
+            minFontScale,
+        ));
+
+        // 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 dynamicVertex = DynamicVertex::new(labelAnchor.point, 0.);
+        buffer.sharedDynamicVertices.push(dynamicVertex);
+        buffer.sharedDynamicVertices.push(dynamicVertex);
+        buffer.sharedDynamicVertices.push(dynamicVertex);
+        buffer.sharedDynamicVertices.push(dynamicVertex);
+
+        let opacityVertex = OpacityVertex::new(true, 1.0);
+        buffer.sharedOpacityVertices.push(opacityVertex);
+        buffer.sharedOpacityVertices.push(opacityVertex);
+        buffer.sharedOpacityVertices.push(opacityVertex);
+        buffer.sharedOpacityVertices.push(opacityVertex);
+
+        // add the two triangles, referencing the four coordinates we just inserted.
+        buffer.triangles.push(index + 0, index + 1, index + 2);
+        buffer.triangles.push(index + 1, index + 2, index + 3);
+
+        segment.vertexLength += vertexLength as usize;
+        segment.indexLength += 6;
+
+        return index as usize;
+    }
+    fn addSymbols(
+        &self,
+        buffer: &mut SymbolBucketBuffer,
+        sizeData: Range<f64>,
+        symbols: &SymbolQuads,
+        labelAnchor: &Anchor,
+        placedSymbol: &mut PlacedSymbol,
+        sortKey: f64,
+    ) -> usize {
+        let mut firstSymbol = true;
+        let mut firstIndex = 0;
+        for symbol in symbols {
+            let index = self.addSymbol(buffer, sizeData.clone(), symbol, labelAnchor, sortKey);
+            placedSymbol.glyphOffsets.push(symbol.glyphOffset.x);
+            if (firstSymbol) {
+                firstIndex = index;
+                firstSymbol = false;
+            }
+        }
+        return firstIndex;
+    }
+
+    // Adds symbol quads to bucket and returns formatted section index of last
+    // added quad.
+    fn addSymbolGlyphQuads(
+        &self,
+        bucket: &mut SymbolBucket,
+        symbolInstance: &SymbolInstance,
+        feature: &SymbolGeometryTileFeature,
+        writingMode: WritingModeType,
+        placedIndex: Option<usize>, // TODO should this be an output?
+        glyphQuads: &SymbolQuads,
+        canonical: &CanonicalTileID,
+        mut lastAddedSection: Option<usize>, // TODO should this be an output?
+    ) -> (usize, Option<usize>) {
+        let mut outputPlacedIndex = placedIndex;
+        let sizeData: Range<f64> = bucket.textSizeBinder.getVertexSizeData(feature); // TODO verify if usage of range is oke, empty ranges, reverse
+        let hasFormatSectionOverrides: bool = bucket.hasFormatSectionOverrides();
+        let placedIconIndex = if writingMode == WritingModeType::Vertical {
+            symbolInstance.placedVerticalIconIndex
+        } else {
+            symbolInstance.placedIconIndex
+        };
+
+        // TODO is this PlacedSymbol correct?
+        let mut newlyPlacedSymbol = PlacedSymbol {
+            anchorPoint: symbolInstance.anchor.point,
+            segment: symbolInstance.anchor.segment.unwrap_or(0),
+            lowerSize: sizeData.start,
+            upperSize: sizeData.end,
+            lineOffset: symbolInstance.textOffset,
+            writingModes: writingMode,
+            line: symbolInstance.line().clone(),
+            tileDistances: Self::calculateTileDistances(
+                symbolInstance.line(),
+                &symbolInstance.anchor,
+            ),
+
+            glyphOffsets: vec![],
+            hidden: false,
+            vertexStartIndex: 0,
+            crossTileID: 0,
+            placedOrientation: None,
+            angle: if (self.allowVerticalPlacement && writingMode == WritingModeType::Vertical) {
+                PI / 2.
+            } else {
+                0.0
+            },
+            placedIconIndex,
+        };
+
+        let mut firstSymbol = true;
+        for symbolQuad in glyphQuads {
+            if (hasFormatSectionOverrides) {
+                if let Some(lastAddedSection) = lastAddedSection {
+                    if (lastAddedSection != symbolQuad.sectionIndex) {
+                        self.updatePaintPropertiesForSection(
+                            bucket,
+                            feature,
+                            lastAddedSection,
+                            canonical,
+                        );
+                    }
+                }
+
+                lastAddedSection = Some(symbolQuad.sectionIndex);
+            }
+            let index = self.addSymbol(
+                &mut bucket.text,
+                sizeData.clone(),
+                symbolQuad,
+                &symbolInstance.anchor,
+                feature.sortKey,
+            );
+
+            newlyPlacedSymbol
+                .glyphOffsets
+                .push(symbolQuad.glyphOffset.x);
+
+            if (firstSymbol) {
+                newlyPlacedSymbol.vertexStartIndex = index;
+                firstSymbol = false;
+            }
+        }
+
+        bucket.text.placedSymbols.push(newlyPlacedSymbol);
+        outputPlacedIndex = Some(bucket.text.placedSymbols.len() - 1);
+
+        return if let Some(lastAddedSection) = lastAddedSection {
+            (lastAddedSection, outputPlacedIndex)
+        } else {
+            (0, outputPlacedIndex)
+        };
+    }
+
+    fn updatePaintPropertiesForSection(
+        &self,
+        bucket: &SymbolBucket,
+        feature: &SymbolGeometryTileFeature,
+        sectionIndex: usize,
+        canonical: &CanonicalTileID,
+    ) -> usize {
+        let formattedSection = sectionOptionsToValue(
+            feature
+                .formattedText
+                .as_ref()
+                .unwrap()
+                .sectionAt(sectionIndex),
+        );
+        // todo!()
+        // for pair in bucket.paintProperties {
+        //     pair.1.textBinders.populateVertexVectors(
+        //         feature,
+        //         bucket.text.vertices().elements(),
+        //         feature.index,
+        //         {},
+        //         {},
+        //         canonical,
+        //         formattedSection,
+        //     );
+        // }
+        return 0;
+    }
+}
diff --git a/maplibre/src/sdf/layout/symbol_projection.rs b/maplibre/src/sdf/layout/symbol_projection.rs
new file mode 100644
index 000000000..b92b77dda
--- /dev/null
+++ b/maplibre/src/sdf/layout/symbol_projection.rs
@@ -0,0 +1,221 @@
+use std::f64::consts::PI;
+
+use cgmath::{Matrix4, Vector4};
+
+use crate::{
+    euclid::Point2D,
+    sdf::{
+        buckets::symbol_bucket::PlacedSymbol, geometry::convert_point_f64,
+        geometry_tile_data::GeometryCoordinates, util::math::perp, TileSpace,
+    },
+};
+
+type PointAndCameraDistance = (Point2D<f64, TileSpace>, f64); // TODO is the Unit correct?
+
+pub struct TileDistance {
+    pub prevTileDistance: f64,
+    pub lastSegmentViewportDistance: f64,
+}
+
+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
+    return (Point2D::new(pos[0] / pos[3], pos[1] / pos[3]), pos[3]);
+}
+
+pub struct PlacedGlyph {
+    pub point: Point2D<f64, TileSpace>,
+    pub angle: f64,
+    pub tileDistance: Option<TileDistance>,
+}
+
+pub fn placeFirstAndLastGlyph(
+    fontScale: f64,
+    lineOffsetX: f64,
+    lineOffsetY: f64,
+    flip: bool,
+    anchorPoint: Point2D<f64, TileSpace>,
+    tileAnchorPoint: Point2D<f64, TileSpace>,
+    symbol: &PlacedSymbol,
+    labelPlaneMatrix: &Matrix4<f64>,
+    returnTileDistance: bool,
+) -> Option<(PlacedGlyph, PlacedGlyph)> {
+    if (symbol.glyphOffsets.is_empty()) {
+        assert!(false);
+        return None;
+    }
+
+    let firstGlyphOffset = *symbol.glyphOffsets.first().unwrap();
+    let lastGlyphOffset = *symbol.glyphOffsets.last().unwrap();
+
+    if let (Some(firstPlacedGlyph), Some(lastPlacedGlyph)) = (
+        placeGlyphAlongLine(
+            fontScale * firstGlyphOffset,
+            lineOffsetX,
+            lineOffsetY,
+            flip,
+            &anchorPoint,
+            &tileAnchorPoint,
+            symbol.segment as i16,
+            &symbol.line,
+            &symbol.tileDistances,
+            labelPlaneMatrix,
+            returnTileDistance,
+        ),
+        placeGlyphAlongLine(
+            fontScale * lastGlyphOffset,
+            lineOffsetX,
+            lineOffsetY,
+            flip,
+            &anchorPoint,
+            &tileAnchorPoint,
+            symbol.segment as i16,
+            &symbol.line,
+            &symbol.tileDistances,
+            labelPlaneMatrix,
+            returnTileDistance,
+        ),
+    ) {
+        return Some((firstPlacedGlyph, lastPlacedGlyph));
+    }
+
+    return None;
+}
+
+fn placeGlyphAlongLine(
+    offsetX: f64,
+    lineOffsetX: f64,
+    lineOffsetY: f64,
+    flip: bool,
+    projectedAnchorPoint: &Point2D<f64, TileSpace>,
+    tileAnchorPoint: &Point2D<f64, TileSpace>,
+    anchorSegment: i16,
+    line: &GeometryCoordinates,
+    tileDistances: &Vec<f64>,
+    labelPlaneMatrix: &Matrix4<f64>,
+    returnTileDistance: bool,
+) -> Option<PlacedGlyph> {
+    let combinedOffsetX = if flip {
+        offsetX - lineOffsetX
+    } else {
+        offsetX + lineOffsetX
+    };
+
+    let mut dir: i16 = if combinedOffsetX > 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 currentIndex = if dir > 0 {
+        anchorSegment
+    } else {
+        anchorSegment + 1
+    };
+
+    let initialIndex = currentIndex;
+    let mut current = *projectedAnchorPoint;
+    let mut prev = *projectedAnchorPoint;
+    let mut distanceToPrev = 0.0;
+    let mut currentSegmentDistance = 0.0;
+    let absOffsetX = combinedOffsetX.abs();
+
+    while (distanceToPrev + currentSegmentDistance <= absOffsetX) {
+        currentIndex += dir;
+
+        // offset does not fit on the projected line
+        if (currentIndex < 0 || currentIndex >= line.len() as i16) {
+            return None;
+        }
+
+        prev = current;
+        let projection = project(
+            convert_point_f64(&line[currentIndex as usize]),
+            labelPlaneMatrix,
+        );
+        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 previousTilePoint = if distanceToPrev == 0. {
+                *tileAnchorPoint
+            } else {
+                convert_point_f64(&line[(currentIndex - dir) as usize])
+            };
+
+            let currentTilePoint = convert_point_f64(&line[currentIndex as usize]);
+            current = projectTruncatedLineSegment(
+                &previousTilePoint,
+                &currentTilePoint,
+                &prev,
+                absOffsetX - distanceToPrev + 1.,
+                labelPlaneMatrix,
+            );
+        }
+
+        distanceToPrev += currentSegmentDistance;
+        currentSegmentDistance = prev.distance_to(current); // TODO verify distance calculation is correct
+    }
+
+    // The point is on the current segment. Interpolate to find it.
+    let segmentInterpolationT = (absOffsetX - distanceToPrev) / currentSegmentDistance;
+    let prevToCurrent = current - prev;
+    let mut p = prev + (prevToCurrent * segmentInterpolationT);
+
+    // offset the point from the line to text-offset and icon-offset
+    p += perp(&prevToCurrent) * (lineOffsetY * dir as f64 / prevToCurrent.length()) as f64; // TODO verify if mag impl is correct mag == length?
+
+    let segmentAngle = angle + (current.y - prev.y).atan2(current.x - prev.x); // TODO is this atan2 right?
+
+    return Some(PlacedGlyph {
+        point: p,
+        angle: segmentAngle,
+        tileDistance: if returnTileDistance {
+            Some(TileDistance {
+                // TODO are these the right fields assigned?
+                prevTileDistance: if (currentIndex - dir) == initialIndex {
+                    0.
+                } else {
+                    tileDistances[(currentIndex - dir) as usize]
+                },
+                lastSegmentViewportDistance: absOffsetX - distanceToPrev,
+            })
+        } else {
+            None
+        },
+    });
+}
+
+fn projectTruncatedLineSegment(
+    &previousTilePoint: &Point2D<f64, TileSpace>,
+    currentTilePoint: &Point2D<f64, TileSpace>,
+    previousProjectedPoint: &Point2D<f64, TileSpace>,
+    minimumLength: f64,
+    projectionMatrix: &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 = (previousTilePoint.clone() - currentTilePoint.clone());
+    let projectedUnitVertex = project(
+        previousTilePoint + vec.try_normalize().unwrap_or(vec),
+        projectionMatrix,
+    )
+    .0;
+    let projectedUnitSegment = previousProjectedPoint.clone() - projectedUnitVertex.clone();
+
+    return previousProjectedPoint.clone()
+        + (projectedUnitSegment * (minimumLength / projectedUnitSegment.length()));
+    // TODO verify if mag impl is correct mag == length?
+}
diff --git a/maplibre/src/sdf/mod.rs b/maplibre/src/sdf/mod.rs
new file mode 100644
index 000000000..78fd0f047
--- /dev/null
+++ b/maplibre/src/sdf/mod.rs
@@ -0,0 +1,293 @@
+use std::{
+    marker::PhantomData,
+    ops::{Deref, Range},
+    rc::Rc,
+};
+
+use crate::{
+    coords::WorldTileCoords,
+    environment::Environment,
+    euclid::{Box2D, Point2D},
+    kernel::Kernel,
+    plugin::Plugin,
+    render::{
+        eventually::Eventually,
+        graph::RenderGraph,
+        shaders::{SDFShaderFeatureMetadata, ShaderLayerMetadata, ShaderSymbolVertex},
+        RenderStageLabel,
+    },
+    schedule::Schedule,
+    sdf::resource::GlyphTexture,
+    tcs::{system::SystemContainer, tiles::TileComponent, world::World},
+    vector::{
+        resource::BufferPool,
+        tessellation::{IndexDataType, OverAlignedVertexBuffer},
+        VectorTransferables,
+    },
+};
+use crate::sdf::layout::symbol_layout::LayerRenderData;
+
+mod populate_world_system;
+mod queue_system;
+mod render_commands;
+mod resource;
+mod resource_system;
+mod upload_system;
+
+// Public due to bechmarks
+mod bidi;
+mod buckets;
+mod collision_feature;
+mod collision_index;
+mod collision_system;
+mod font_stack;
+mod geometry;
+mod geometry_tile_data;
+mod glyph;
+mod glyph_atlas;
+mod glyph_range;
+mod grid_index;
+mod image;
+mod image_atlas;
+mod layout;
+mod quads;
+mod shaping;
+mod style_types;
+mod tagged_string;
+pub mod tessellation;
+mod text;
+mod util;
+mod tessellation_new;
+
+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,
+    ShaderSymbolVertex,
+    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: LayerRenderData, // TODO
+    pub features: Vec<Feature>,
+}
+
+#[derive(Default)]
+pub struct SymbolLayersDataComponent {
+    pub layers: Vec<SymbolLayerData>,
+}
+
+impl TileComponent for SymbolLayersDataComponent {}
+
+// 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?
+#[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
+#[derive(Copy, Clone)]
+pub struct CanonicalTileID {
+    pub x: u32,
+    pub y: u32,
+    pub z: u8,
+}
+
+// TODO
+#[derive(Copy, Clone)]
+struct OverscaledTileID {
+    pub canonical: CanonicalTileID,
+    pub overscaledZ: u8,
+}
+
+impl OverscaledTileID {
+    pub fn overscaleFactor(&self) -> u32 {
+        return 1 << (self.overscaledZ - self.canonical.z);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use crate::{
+        euclid::{Point2D, Rect, Size2D},
+        sdf::{
+            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 },
+            overscaledZ: 0,
+        };
+        let mut parameters = BucketParameters {
+            tileID: tile_id,
+            mode: MapMode::Continuous,
+            pixelRatio: 1.0,
+            layerType: 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 {
+                bucketParameters: &mut parameters.clone(),
+                glyphDependencies: &mut glyphDependencies,
+                imageDependencies: &mut Default::default(),
+                availableImages: &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.prepareSymbols(&glyphs, &glyphPositions, &empty_image_map, &image_positions);
+
+        let mut output = HashMap::new();
+        layout.createBucket(
+            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/quads.rs b/maplibre/src/sdf/quads.rs
new file mode 100644
index 000000000..11e8fe9af
--- /dev/null
+++ b/maplibre/src/sdf/quads.rs
@@ -0,0 +1,875 @@
+use std::f64::consts::PI;
+
+use crate::{
+    euclid::{Point2D, Rect, Size2D, Vector2D},
+    sdf::{
+        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,
+    },
+};
+
+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 pixelOffsetTL: Point2D<f64, TileSpace>,
+    pub pixelOffsetBR: Point2D<f64, TileSpace>,
+    pub glyphOffset: Point2D<f64, TileSpace>,
+    pub writingMode: WritingModeType,
+    pub isSDF: bool,
+    pub sectionIndex: usize,
+    pub minFontScale: Point2D<f64, TileSpace>,
+}
+
+pub type SymbolQuads = Vec<SymbolQuad>;
+
+const border: u16 = ImagePosition::padding;
+
+fn computeStretchSum(stretches: &ImageStretches) -> f64 {
+    let mut sum = 0.;
+    for stretch in stretches {
+        sum += stretch.1 - stretch.0;
+    }
+    return sum;
+}
+
+fn sumWithinRange(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));
+    }
+    return sum;
+}
+
+fn getEmOffset(stretchOffset: f64, stretchSize: f64, iconSize: f64, iconOffset: f64) -> f64 {
+    return iconOffset + iconSize * stretchOffset / stretchSize;
+}
+
+fn getPxOffset(fixedOffset: f64, fixedSize: f64, stretchOffset: f64, stretchSize: f64) -> f64 {
+    return fixedOffset - fixedSize * stretchOffset / stretchSize;
+}
+
+struct Cut {
+    fixed: f64,
+    stretch: f64,
+}
+
+type Cuts = Vec<Cut>;
+
+fn stretchZonesToCuts(stretchZones: &ImageStretches, fixedSize: f64, stretchSize: f64) -> Cuts {
+    let mut cuts = vec![Cut {
+        fixed: -(border as f64),
+        stretch: 0.0,
+    }];
+
+    for zone in stretchZones {
+        let c1 = zone.0;
+        let c2 = zone.1;
+        let lastStretch = cuts.last().unwrap().stretch;
+        cuts.push(Cut {
+            fixed: c1 - lastStretch,
+            stretch: lastStretch,
+        });
+        cuts.push(Cut {
+            fixed: c1 - lastStretch,
+            stretch: lastStretch + (c2 - c1),
+        });
+    }
+    cuts.push(Cut {
+        fixed: fixedSize + border as f64,
+        stretch: stretchSize,
+    });
+    return cuts;
+}
+
+fn matrixMultiply<U>(m: &[f64; 4], p: Point2D<f64, U>) -> Point2D<f64, U> {
+    return Point2D::<f64, U>::new(m[0] * p.x + m[1] * p.y, m[2] * p.x + m[3] * p.y);
+}
+
+pub fn getIconQuads(
+    shapedIcon: &PositionedIcon,
+    iconRotate: f64,
+    iconType: SymbolContent,
+    hasIconTextFit: bool,
+) -> SymbolQuads {
+    let mut quads = Vec::new();
+
+    let image = &shapedIcon.image;
+    let pixelRatio = image.pixelRatio;
+    let imageWidth: u16 = image.paddedRect.width() - 2 * border;
+    let imageHeight: u16 = image.paddedRect.height() - 2 * border;
+
+    let iconWidth = shapedIcon.right - shapedIcon.left;
+    let iconHeight = shapedIcon.bottom - shapedIcon.top;
+
+    let stretchXFull: ImageStretches = vec![(0.0, imageWidth as f64)];
+    let stretchYFull: ImageStretches = vec![(0.0, imageHeight as f64)];
+    let stretchX: &ImageStretches = if !image.stretchX.is_empty() {
+        &image.stretchX
+    } else {
+        &stretchXFull
+    };
+    let stretchY: &ImageStretches = if !image.stretchY.is_empty() {
+        &image.stretchY
+    } else {
+        &stretchYFull
+    };
+
+    let stretchWidth = computeStretchSum(stretchX);
+    let stretchHeight = computeStretchSum(stretchY);
+    let fixedWidth = imageWidth as f64 - stretchWidth;
+    let fixedHeight = imageHeight as f64 - stretchHeight;
+
+    let mut stretchOffsetX = 0.;
+    let mut stretchContentWidth = stretchWidth;
+    let mut stretchOffsetY = 0.;
+    let mut stretchContentHeight = stretchHeight;
+    let mut fixedOffsetX = 0.;
+    let mut fixedContentWidth = fixedWidth;
+    let mut fixedOffsetY = 0.;
+    let mut fixedContentHeight = fixedHeight;
+
+    if (hasIconTextFit) {
+        if let Some(content) = &image.content {
+            stretchOffsetX = sumWithinRange(stretchX, 0., content.left);
+            stretchOffsetY = sumWithinRange(stretchY, 0., content.top);
+            stretchContentWidth = sumWithinRange(stretchX, content.left, content.right);
+            stretchContentHeight = sumWithinRange(stretchY, content.top, content.bottom);
+            fixedOffsetX = content.left - stretchOffsetX;
+            fixedOffsetY = content.top - stretchOffsetY;
+            fixedContentWidth = content.right - content.left - stretchContentWidth;
+            fixedContentHeight = content.bottom - content.top - stretchContentHeight;
+        }
+    }
+
+    let mut matrix: Option<[f64; 4]> = None;
+    if (iconRotate != 0.0) {
+        // TODO is this correct?
+        let angle = deg2radf(iconRotate);
+        let angle_sin = (angle.sin());
+        let angle_cos = (angle.cos());
+        matrix = Some([angle_cos, -angle_sin, angle_sin, angle_cos]);
+    }
+
+    let mut makeBox = |left: &Cut, top: &Cut, right: &Cut, bottom: &Cut| {
+        let leftEm = getEmOffset(
+            left.stretch - stretchOffsetX,
+            stretchContentWidth,
+            iconWidth,
+            shapedIcon.left,
+        );
+        let leftPx = getPxOffset(
+            left.fixed - fixedOffsetX,
+            fixedContentWidth,
+            left.stretch,
+            stretchWidth,
+        );
+
+        let topEm = getEmOffset(
+            top.stretch - stretchOffsetY,
+            stretchContentHeight,
+            iconHeight,
+            shapedIcon.top,
+        );
+        let topPx = getPxOffset(
+            top.fixed - fixedOffsetY,
+            fixedContentHeight,
+            top.stretch,
+            stretchHeight,
+        );
+
+        let rightEm = getEmOffset(
+            right.stretch - stretchOffsetX,
+            stretchContentWidth,
+            iconWidth,
+            shapedIcon.left,
+        );
+        let rightPx = getPxOffset(
+            right.fixed - fixedOffsetX,
+            fixedContentWidth,
+            right.stretch,
+            stretchWidth,
+        );
+
+        let bottomEm = getEmOffset(
+            bottom.stretch - stretchOffsetY,
+            stretchContentHeight,
+            iconHeight,
+            shapedIcon.top,
+        );
+        let bottomPx = getPxOffset(
+            bottom.fixed - fixedOffsetY,
+            fixedContentHeight,
+            bottom.stretch,
+            stretchHeight,
+        );
+
+        let mut tl = Point2D::<f64, TileSpace>::new(leftEm, topEm);
+        let mut tr = Point2D::<f64, TileSpace>::new(rightEm, topEm);
+        let mut br = Point2D::<f64, TileSpace>::new(rightEm, bottomEm);
+        let mut bl = Point2D::<f64, TileSpace>::new(leftEm, bottomEm);
+        let pixelOffsetTL = Point2D::<f64, TileSpace>::new(leftPx / pixelRatio, topPx / pixelRatio);
+        let pixelOffsetBR =
+            Point2D::<f64, TileSpace>::new(rightPx / pixelRatio, bottomPx / pixelRatio);
+
+        if let Some(matrix) = matrix {
+            tl = matrixMultiply(&matrix, tl);
+            tr = matrixMultiply(&matrix, tr);
+            bl = matrixMultiply(&matrix, bl);
+            br = matrixMultiply(&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 subRect: Rect<u16, TileSpace> = Rect::new(
+            Point2D::new(
+                (image.paddedRect.origin.x as f64 + border as f64 + x1) as u16,
+                (image.paddedRect.origin.y as f64 + border as f64 + y1) as u16,
+            ),
+            Size2D::new((x2 - x1) as u16, (y2 - y1) as u16),
+        );
+
+        let minFontScaleX = fixedContentWidth / pixelRatio / iconWidth;
+        let minFontScaleY = fixedContentHeight / pixelRatio / iconHeight;
+
+        // Icon quad is padded, so texture coordinates also need to be padded.
+        quads.push(SymbolQuad {
+            tl,
+            tr,
+            bl,
+            br,
+            tex: subRect,
+            pixelOffsetTL,
+            pixelOffsetBR,
+            glyphOffset: Point2D::new(0.0, 0.0),
+            writingMode: WritingModeType::None,
+            isSDF: iconType == SymbolContent::IconSDF,
+            sectionIndex: 0,
+            minFontScale: Point2D::new(minFontScaleX, minFontScaleY),
+        });
+    };
+
+    if (!hasIconTextFit || (image.stretchX.is_empty() && image.stretchY.is_empty())) {
+        makeBox(
+            &Cut {
+                fixed: 0.,
+                stretch: -1.,
+            },
+            &Cut {
+                fixed: 0.,
+                stretch: -1.,
+            },
+            &Cut {
+                fixed: 0.,
+                stretch: (imageWidth + 1) as f64,
+            },
+            &Cut {
+                fixed: 0.,
+                stretch: (imageHeight + 1) as f64,
+            },
+        );
+    } else {
+        let xCuts = stretchZonesToCuts(stretchX, fixedWidth, stretchWidth);
+        let yCuts = stretchZonesToCuts(stretchY, fixedHeight, stretchHeight);
+
+        for xi in 0..xCuts.len() - 1 {
+            let x1 = &xCuts[xi];
+            let x2 = &xCuts[xi + 1];
+            for yi in 0..yCuts.len() - 1 {
+                let y1 = &yCuts[yi];
+                let y2 = &yCuts[yi + 1];
+                makeBox(x1, y1, x2, y2);
+            }
+        }
+    }
+
+    return quads;
+}
+
+pub fn getGlyphQuads(
+    shapedText: &Shaping,
+    textOffset: [f64; 2],
+    layout: &SymbolLayoutProperties_Evaluated,
+    placement: SymbolPlacementType,
+    imageMap: &ImageMap,
+    allowVerticalPlacement: bool,
+) -> SymbolQuads {
+    let textRotate: f64 = deg2radf(layout.get_eval::<TextRotate>());
+    let alongLine: bool = layout.get::<TextRotationAlignment>() == AlignmentType::Map
+        && placement != SymbolPlacementType::Point;
+
+    let mut quads = Vec::new();
+
+    for line in &shapedText.positionedLines {
+        for positionedGlyph in &line.positionedGlyphs {
+            if (positionedGlyph.rect.is_empty()) {
+                continue;
+            }
+
+            // The rects have an addditional buffer that is not included in their size;
+            let glyphPadding = 1.0;
+            let mut rectBuffer = 3.0 + glyphPadding;
+            let mut pixelRatio = 1.0;
+            let mut lineOffset = 0.0;
+            let rotateVerticalGlyph =
+                (alongLine || allowVerticalPlacement) && positionedGlyph.vertical;
+            let halfAdvance = positionedGlyph.metrics.advance as f64 * positionedGlyph.scale / 2.0;
+            let rect = positionedGlyph.rect;
+            let mut isSDF = true;
+
+            // Align images and scaled glyphs in the middle of a vertical line.
+            if (allowVerticalPlacement && shapedText.verticalizable) {
+                let scaledGlyphOffset = (positionedGlyph.scale - 1.) * ONE_EM;
+                let imageOffset =
+                    (ONE_EM - positionedGlyph.metrics.width as f64 * positionedGlyph.scale) / 2.0;
+                lineOffset = line.lineOffset / 2.0
+                    - (if positionedGlyph.imageID.is_some() {
+                        -imageOffset
+                    } else {
+                        scaledGlyphOffset
+                    });
+            }
+
+            if let Some(imageID) = (&positionedGlyph.imageID) {
+                let image = imageMap.get(imageID);
+                if let Some(image) = image {
+                    pixelRatio = image.pixelRatio;
+                    rectBuffer = ImagePosition::padding as f64 / pixelRatio;
+                    isSDF = image.sdf;
+                }
+            }
+
+            let glyphOffset = if alongLine {
+                Point2D::new(positionedGlyph.x + halfAdvance, positionedGlyph.y)
+            } else {
+                Point2D::new(0.0, 0.0)
+            };
+
+            let mut builtInOffset = if alongLine {
+                Vector2D::new(0.0, 0.0)
+            } else {
+                Vector2D::new(
+                    positionedGlyph.x + halfAdvance + textOffset[0],
+                    positionedGlyph.y + textOffset[1] - lineOffset,
+                )
+            };
+
+            let mut verticalizedLabelOffset = Vector2D::<f64, TileSpace>::new(0.0, 0.0);
+            if (rotateVerticalGlyph) {
+                // 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.
+                verticalizedLabelOffset = builtInOffset;
+                builtInOffset = Vector2D::new(0.0, 0.0);
+            }
+
+            let x1 = (positionedGlyph.metrics.left as f64 - rectBuffer) * positionedGlyph.scale
+                - halfAdvance
+                + builtInOffset.x;
+            let y1 = (-positionedGlyph.metrics.top as f64 - rectBuffer) * positionedGlyph.scale
+                + builtInOffset.y;
+            let x2 = x1 + rect.width() as f64 * positionedGlyph.scale / pixelRatio;
+            let y2 = y1 + rect.height() as f64 * positionedGlyph.scale / pixelRatio;
+
+            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 (rotateVerticalGlyph) {
+                // 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(-halfAdvance, halfAdvance - Shaping::yOffset as f64);
+                let verticalRotation = -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 xHalfWidhtOffsetcorrection = ONE_EM / 2. - halfAdvance;
+                let yImageOffsetCorrection = if positionedGlyph.imageID.is_some() {
+                    xHalfWidhtOffsetcorrection
+                } else {
+                    0.0
+                };
+
+                let xOffsetCorrection = Vector2D::<f64, TileSpace>::new(
+                    5.0 - Shaping::yOffset as f64 - xHalfWidhtOffsetcorrection,
+                    -yImageOffsetCorrection,
+                );
+
+                tl = center
+                    + rotate(&(tl - center), verticalRotation)
+                    + xOffsetCorrection
+                    + verticalizedLabelOffset;
+                tr = center
+                    + rotate(&(tr - center), verticalRotation)
+                    + xOffsetCorrection
+                    + verticalizedLabelOffset;
+                bl = center
+                    + rotate(&(bl - center), verticalRotation)
+                    + xOffsetCorrection
+                    + verticalizedLabelOffset;
+                br = center
+                    + rotate(&(br - center), verticalRotation)
+                    + xOffsetCorrection
+                    + verticalizedLabelOffset;
+            }
+
+            if (textRotate != 0.0) {
+                // TODO is this correct?
+                // Compute the transformation matrix.
+                let angle_sin = textRotate.sin();
+                let angle_cos = textRotate.cos();
+                let matrix = [angle_cos, -angle_sin, angle_sin, angle_cos];
+
+                tl = matrixMultiply(&matrix, tl);
+                tr = matrixMultiply(&matrix, tr);
+                bl = matrixMultiply(&matrix, bl);
+                br = matrixMultiply(&matrix, br);
+            }
+
+            let pixelOffsetTL = Point2D::default();
+            let pixelOffsetBR = Point2D::default();
+            let minFontScale = Point2D::default();
+
+            quads.push(SymbolQuad {
+                tl,
+                tr,
+                bl,
+                br,
+                tex: rect,
+                pixelOffsetTL,
+                pixelOffsetBR,
+                glyphOffset: glyphOffset,
+                writingMode: shapedText.writingMode,
+                isSDF: isSDF,
+                sectionIndex: positionedGlyph.sectionIndex,
+                minFontScale: minFontScale,
+            });
+        }
+    }
+
+    return quads;
+}
+#[cfg(test)]
+mod tests {
+    use cgmath::ulps_eq;
+
+    use crate::{
+        euclid::{Point2D, Rect, Size2D},
+        sdf::{
+            geometry::Anchor,
+            geometry_tile_data::GeometryCoordinates,
+            glyph::{PositionedGlyph, PositionedLine, Shaping, WritingModeType},
+            image_atlas::ImagePosition,
+            layout::symbol_instance::SymbolContent,
+            quads::getIconQuads,
+            shaping::PositionedIcon,
+            style_types::{IconTextFitType, SymbolAnchorType, SymbolLayoutProperties_Evaluated},
+        },
+    };
+
+    #[test]
+    pub fn getIconQuads_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 {
+            pixelRatio: 1.0,
+            paddedRect: Rect::new(Point2D::origin(), Size2D::new(15, 11)),
+            version: 0,
+            stretchX: vec![],
+            stretchY: vec![],
+            content: None,
+        };
+
+        let shapedIcon =
+            PositionedIcon::shapeIcon(image.clone(), &[-6.5, -4.5], SymbolAnchorType::Center);
+
+        let quads = getIconQuads(&shapedIcon, 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]
+    pub fn getIconQuads_style() {
+        let anchor = Anchor {
+            point: Point2D::new(0.0, 0.0),
+            angle: 0.0,
+            segment: Some(0),
+        };
+
+        let image: ImagePosition = ImagePosition {
+            pixelRatio: 1.0,
+            paddedRect: Rect::new(Point2D::origin(), Size2D::new(20, 20)),
+            version: 0,
+            stretchX: vec![],
+            stretchY: vec![],
+            content: None,
+        };
+
+        let line = GeometryCoordinates::default();
+        let mut shapedText: Shaping = Shaping {
+            top: -10.,
+            bottom: 30.0,
+            left: -60.,
+            right: 20.0,
+
+            positionedLines: vec![],
+            writingMode: WritingModeType::None,
+            verticalizable: false,
+            iconsInText: false,
+        };
+
+        // shapedText.positionedGlyphs.emplace_back(PositionedGlyph(32, 0.0, 0.0, false, 0, 1.0));
+
+        shapedText.positionedLines.push(PositionedLine::default());
+        shapedText
+            .positionedLines
+            .last_mut()
+            .unwrap()
+            .positionedGlyphs
+            .push(PositionedGlyph {
+                glyph: 32,
+                x: 0.0,
+                y: 0.0,
+                vertical: false,
+                font: 0,
+                scale: 0.0,
+                rect: Default::default(),
+                metrics: Default::default(),
+                imageID: None,
+                sectionIndex: 0,
+            });
+
+        // none
+        {
+            let shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+
+            ulps_eq!(-18.5, shapedIcon.top);
+            ulps_eq!(-0.5, shapedIcon.right);
+            ulps_eq!(-0.5, shapedIcon.bottom);
+            ulps_eq!(-18.5, shapedIcon.left);
+
+            let layout = SymbolLayoutProperties_Evaluated;
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Width,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                24.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Width,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Width,
+                &[5., 10., 5., 10.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Height,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                24.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Height,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Height,
+                &[5., 10., 5., 20.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Both,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                24.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Both,
+                &[0., 0., 0., 0.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Both,
+                &[5., 10., 5., 10.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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 shapedIcon =
+                PositionedIcon::shapeIcon(image.clone(), &[-9.5, -9.5], SymbolAnchorType::Center);
+            shapedIcon.fitIconToText(
+                &shapedText,
+                IconTextFitType::Both,
+                &[0., 5., 10., 15.],
+                &[0., 0.],
+                12.0 / 24.0,
+            );
+            let quads = getIconQuads(&shapedIcon, 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/sdf/queue_system.rs b/maplibre/src/sdf/queue_system.rs
new file mode 100644
index 000000000..c9a6150e4
--- /dev/null
+++ b/maplibre/src/sdf/queue_system.rs
@@ -0,0 +1,52 @@
+//! 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..8aeb8d656
--- /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..04a448cba
--- /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: &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..a258e1743
--- /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/shaping.rs b/maplibre/src/sdf/shaping.rs
new file mode 100644
index 000000000..b64b0439a
--- /dev/null
+++ b/maplibre/src/sdf/shaping.rs
@@ -0,0 +1,895 @@
+use std::collections::BTreeSet;
+
+use cgmath::num_traits::Pow;
+
+use crate::{
+    euclid::Rect,
+    sdf::{
+        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,
+    },
+};
+
+#[derive(Clone, Copy, Default, PartialEq)]
+pub struct Padding {
+    pub left: f64,
+    pub top: f64,
+    pub right: f64,
+    pub bottom: f64,
+}
+
+impl Into<bool> for Padding {
+    fn into(self) -> bool {
+        self.left != 0. || self.top != 0. || self.right != 0. || self.bottom != 0.
+    }
+}
+
+struct AnchorAlignment {
+    horizontalAlign: f64,
+    verticalAlign: f64,
+}
+impl AnchorAlignment {
+    fn getAnchorAlignment(anchor: SymbolAnchorType) -> AnchorAlignment {
+        let mut result = AnchorAlignment {
+            horizontalAlign: 0.5,
+            verticalAlign: 0.5,
+        };
+
+        match (anchor) {
+            SymbolAnchorType::Right
+            | SymbolAnchorType::TopRight
+            | SymbolAnchorType::BottomRight => {
+                result.horizontalAlign = 1.0;
+            }
+
+            SymbolAnchorType::Left | SymbolAnchorType::TopLeft | SymbolAnchorType::BottomLeft => {
+                result.horizontalAlign = 0.0;
+            }
+            _ => {}
+        }
+
+        match (anchor) {
+            SymbolAnchorType::Bottom
+            | SymbolAnchorType::BottomLeft
+            | SymbolAnchorType::BottomRight => {
+                result.verticalAlign = 1.0;
+            }
+
+            SymbolAnchorType::Top | SymbolAnchorType::TopLeft | SymbolAnchorType::TopRight => {
+                result.verticalAlign = 0.0;
+            }
+
+            _ => {}
+        }
+
+        return result;
+    }
+}
+
+// Choose the justification that matches the direction of the TextAnchor
+pub fn getAnchorJustification(anchor: &SymbolAnchorType) -> TextJustifyType {
+    match (anchor) {
+        SymbolAnchorType::Right | SymbolAnchorType::TopRight | SymbolAnchorType::BottomRight => {
+            TextJustifyType::Right
+        }
+        SymbolAnchorType::Left | SymbolAnchorType::TopLeft | SymbolAnchorType::BottomLeft => {
+            TextJustifyType::Left
+        }
+        _ => TextJustifyType::Center,
+    }
+}
+
+#[derive(Clone)]
+pub struct PositionedIcon {
+    pub image: ImagePosition,
+    pub top: f64,
+    pub bottom: f64,
+    pub left: f64,
+    pub right: f64,
+    pub collisionPadding: Padding,
+}
+
+impl PositionedIcon {
+    pub fn shapeIcon(
+        image: ImagePosition,
+        iconOffset: &[f64; 2],
+        iconAnchor: SymbolAnchorType,
+    ) -> PositionedIcon {
+        let anchorAlign = AnchorAlignment::getAnchorAlignment(iconAnchor);
+        let dx = iconOffset[0];
+        let dy = iconOffset[1];
+        let left = dx - image.displaySize()[0] * anchorAlign.horizontalAlign;
+        let right = left + image.displaySize()[0];
+        let top = dy - image.displaySize()[1] * anchorAlign.verticalAlign;
+        let bottom = top + image.displaySize()[1];
+
+        let mut collisionPadding: Padding = Padding::default();
+        if let Some(content) = (&image.content) {
+            let content = content;
+            let pixelRatio = image.pixelRatio;
+            collisionPadding.left = content.left / pixelRatio;
+            collisionPadding.top = content.top / pixelRatio;
+            collisionPadding.right = image.displaySize()[0] - content.right / pixelRatio;
+            collisionPadding.bottom = image.displaySize()[1] - content.bottom / pixelRatio;
+        }
+
+        return PositionedIcon {
+            image,
+            top,
+            bottom,
+            left,
+            right,
+            collisionPadding,
+        };
+    }
+
+    // Updates shaped icon's bounds based on shaped text's bounds and provided
+    // layout properties.
+    pub fn fitIconToText(
+        &mut self,
+        shapedText: &Shaping,
+        textFit: IconTextFitType,
+        padding: &[f64; 4],
+        iconOffset: &[f64; 2],
+        fontScale: f64,
+    ) {
+        assert!(textFit != 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 textLeft = shapedText.left * fontScale;
+        let textRight = shapedText.right * fontScale;
+
+        if (textFit == IconTextFitType::Width || textFit == IconTextFitType::Both) {
+            // Stretched horizontally to the text width
+            self.left = iconOffset[0] + textLeft - padding[3];
+            self.right = iconOffset[0] + textRight + padding[1];
+        } else {
+            // Centered on the text
+            self.left = iconOffset[0] + (textLeft + textRight - self.image.displaySize()[0]) / 2.0;
+            self.right = self.left + self.image.displaySize()[0];
+        }
+
+        let textTop = shapedText.top * fontScale;
+        let textBottom = shapedText.bottom * fontScale;
+        if (textFit == IconTextFitType::Height || textFit == IconTextFitType::Both) {
+            // Stretched vertically to the text height
+            self.top = iconOffset[1] + textTop - padding[0];
+            self.bottom = iconOffset[1] + textBottom + padding[2];
+        } else {
+            // Centered on the text
+            self.top = iconOffset[1] + (textTop + textBottom - self.image.displaySize()[1]) / 2.0;
+            self.bottom = self.top + self.image.displaySize()[1];
+        }
+    }
+}
+
+pub fn getShaping(
+    formattedString: &TaggedString,
+    maxWidth: f64,
+    lineHeight: f64,
+    textAnchor: SymbolAnchorType,
+
+    textJustify: TextJustifyType,
+    spacing: f64,
+    translate: &[f64; 2],
+    writingMode: WritingModeType,
+    bidi: &BiDi,
+    glyphMap: &GlyphMap,
+    glyphPositions: &GlyphPositions,
+    imagePositions: &ImagePositions,
+    layoutTextSize: f64,
+    layoutTextSizeAtBucketZoomLevel: f64,
+    allowVerticalPlacement: bool,
+) -> Shaping {
+    assert!(layoutTextSize != 0.);
+    let mut reorderedLines: Vec<TaggedString> = Vec::new();
+    if (formattedString.sectionCount() == 1) {
+        let untaggedLines = bidi.processText(
+            formattedString.rawText(),
+            determineLineBreaks(
+                formattedString,
+                spacing,
+                maxWidth,
+                glyphMap,
+                imagePositions,
+                layoutTextSize,
+            ),
+        );
+        for line in untaggedLines {
+            reorderedLines.push(TaggedString::new_from_raw(
+                line,
+                formattedString.sectionAt(0).clone(),
+            ));
+        }
+    } else {
+        let processedLines = bidi.processStyledText(
+            formattedString.getStyledText(),
+            determineLineBreaks(
+                formattedString,
+                spacing,
+                maxWidth,
+                glyphMap,
+                imagePositions,
+                layoutTextSize,
+            ),
+        );
+        for line in processedLines {
+            reorderedLines.push(TaggedString::new(
+                line,
+                formattedString.getSections().clone(),
+            ));
+        }
+    }
+    let mut shaping = Shaping::new(translate[0], translate[1], writingMode);
+    shapeLines(
+        &mut shaping,
+        &mut reorderedLines,
+        spacing,
+        lineHeight,
+        textAnchor,
+        textJustify,
+        writingMode,
+        glyphMap,
+        &glyphPositions,
+        imagePositions,
+        layoutTextSizeAtBucketZoomLevel,
+        allowVerticalPlacement,
+    );
+
+    return shaping;
+}
+
+// Zero width space that is used to suggest break points for Japanese labels.
+const ZWSP: Char16 = '\u{200b}' as Char16;
+
+fn align(
+    shaping: &mut Shaping,
+    justify: f64,
+    horizontalAlign: f64,
+    verticalAlign: f64,
+    maxLineLength: f64,
+    maxLineHeight: f64,
+    lineHeight: f64,
+    blockHeight: f64,
+    lineCount: usize,
+) {
+    let shiftX = (justify - horizontalAlign) * maxLineLength;
+    let shiftY = if (maxLineHeight != lineHeight) {
+        -blockHeight * verticalAlign - Shaping::yOffset as f64
+    } else {
+        (-verticalAlign * (lineCount) as f64 + 0.5) * lineHeight
+    };
+
+    for line in &mut shaping.positionedLines {
+        for positionedGlyph in &mut line.positionedGlyphs {
+            positionedGlyph.x += shiftX;
+            positionedGlyph.y += shiftY;
+        }
+    }
+}
+
+// justify left = 0, right = 1, center = .5
+fn justifyLine(positionedGlyphs: &mut Vec<PositionedGlyph>, justify: f64, lineOffset: f64) {
+    if (justify == 0.0 && lineOffset == 0.0) {
+        return;
+    }
+
+    let lastGlyph = positionedGlyphs.last().unwrap();
+    let lastAdvance: f64 = lastGlyph.metrics.advance as f64 * lastGlyph.scale;
+    let lineIndent = lastGlyph.x + lastAdvance as f64 * justify;
+    for positionedGlyph in positionedGlyphs {
+        positionedGlyph.x -= lineIndent;
+        positionedGlyph.y += lineOffset;
+    }
+}
+
+fn getGlyphAdvance(
+    codePoint: Char16,
+    section: &SectionOptions,
+    glyphMap: &GlyphMap,
+    imagePositions: &ImagePositions,
+    layoutTextSize: f64,
+    spacing: f64,
+) -> f64 {
+    if let Some(imageID) = &section.imageID {
+        let image = imagePositions.get(imageID);
+        if (image.is_none()) {
+            return 0.0;
+        }
+        let image = image.unwrap();
+        return image.displaySize()[0] * section.scale as f64 * ONE_EM / layoutTextSize + spacing;
+    } else {
+        let glyphs = glyphMap.get(&section.fontStackHash);
+        if (glyphs.is_none()) {
+            return 0.0;
+        }
+        let glyphs = glyphs.unwrap();
+        let it = glyphs.get(&codePoint);
+
+        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) as f64
+            + spacing;
+    }
+}
+
+fn determineAverageLineWidth(
+    logicalInput: &TaggedString,
+    spacing: f64,
+    maxWidth: f64,
+    glyphMap: &GlyphMap,
+    imagePositions: &ImagePositions,
+    layoutTextSize: f64,
+) -> f64 {
+    let mut totalWidth: f64 = 0.;
+
+    for i in 0..logicalInput.length() {
+        let section = logicalInput.getSection(i);
+        let codePoint: Char16 = logicalInput.getCharCodeAt(i);
+        totalWidth += getGlyphAdvance(
+            codePoint,
+            section,
+            glyphMap,
+            imagePositions,
+            layoutTextSize,
+            spacing,
+        );
+    }
+
+    let targetLineCount = (1.0f64).max((totalWidth / maxWidth).ceil()) as i32;
+    return totalWidth / targetLineCount as f64;
+}
+
+fn calculateBadness(lineWidth: f64, targetWidth: f64, penalty: f64, isLastBreak: bool) -> f64 {
+    let raggedness = (lineWidth - targetWidth).pow(2) as f64;
+    if (isLastBreak) {
+        // Favor finals lines shorter than average over longer than average
+        if (lineWidth < targetWidth) {
+            return raggedness / 2.;
+        } else {
+            return raggedness * 2.;
+        }
+    }
+    if (penalty < 0.) {
+        return raggedness - penalty * penalty;
+    }
+    return raggedness + penalty * penalty;
+}
+
+fn calculatePenalty(
+    codePoint: Char16,
+    nextCodePoint: Char16,
+    penalizableIdeographicBreak: bool,
+) -> f64 {
+    let mut penalty = 0.;
+    // Force break on newline
+    if (codePoint == 0x0au16) {
+        penalty -= 10000.;
+    }
+
+    // Penalize open parenthesis at end of line
+    if (codePoint == 0x28u16 || codePoint == 0xff08u16) {
+        penalty += 50.;
+    }
+
+    // Penalize close parenthesis at beginning of line
+    if (nextCodePoint == 0x29u16 || nextCodePoint == 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 (penalizableIdeographicBreak) {
+        penalty += 150.;
+    }
+
+    return penalty;
+}
+
+#[derive(Clone)]
+struct PotentialBreak {
+    pub index: usize,
+    pub x: f64,
+    pub priorBreak: Option<Box<PotentialBreak>>, // TODO avoid Box
+    pub badness: f64,
+}
+
+fn evaluateBreak(
+    breakIndex: usize,
+    breakX: f64,
+    targetWidth: f64,
+    potentialBreaks: &Vec<PotentialBreak>,
+    penalty: f64,
+    isLastBreak: 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 bestPriorBreak: Option<Box<PotentialBreak>> = None;
+    let mut bestBreakBadness: f64 = calculateBadness(breakX, targetWidth, penalty, isLastBreak);
+    for potentialBreak in potentialBreaks {
+        let lineWidth = breakX - potentialBreak.x;
+        let breakBadness =
+            calculateBadness(lineWidth, targetWidth, penalty, isLastBreak) + potentialBreak.badness;
+        if (breakBadness <= bestBreakBadness) {
+            bestPriorBreak = Some(Box::new(potentialBreak.clone()));
+            bestBreakBadness = breakBadness;
+        }
+    }
+
+    return PotentialBreak {
+        index: breakIndex,
+        x: breakX,
+        priorBreak: bestPriorBreak,
+        badness: bestBreakBadness,
+    };
+}
+
+fn leastBadBreaks(lastLineBreak: &PotentialBreak) -> BTreeSet<usize> {
+    let mut leastBadBreaks: BTreeSet<usize> = BTreeSet::from([lastLineBreak.index]);
+    let mut priorBreak = &lastLineBreak.priorBreak;
+
+    while let Some(priorBreak_) = priorBreak {
+        leastBadBreaks.insert(priorBreak_.index);
+        priorBreak = &priorBreak_.priorBreak;
+    }
+    return leastBadBreaks;
+}
+
+// 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!
+fn determineLineBreaks(
+    logicalInput: &TaggedString,
+    spacing: f64,
+    maxWidth: f64,
+    glyphMap: &GlyphMap,
+    imagePositions: &ImagePositions,
+    layoutTextSize: f64,
+) -> BTreeSet<usize> {
+    if (maxWidth == 0.0) {
+        return BTreeSet::default();
+    }
+
+    if (logicalInput.empty()) {
+        return BTreeSet::default();
+    }
+
+    let targetWidth = determineAverageLineWidth(
+        logicalInput,
+        spacing,
+        maxWidth,
+        glyphMap,
+        imagePositions,
+        layoutTextSize,
+    );
+
+    let mut potentialBreaks: Vec<PotentialBreak> = Vec::new();
+    let mut currentX: f64 = 0.;
+    // Find first occurance of zero width space (ZWSP) character.
+    let hasServerSuggestedBreaks = logicalInput.rawText().as_slice().iter().any(|c| *c == ZWSP);
+
+    for i in 0..logicalInput.length() {
+        let section = logicalInput.getSection(i);
+        let codePoint: Char16 = logicalInput.getCharCodeAt(i);
+        if (!i18n::isWhitespace(codePoint)) {
+            currentX += getGlyphAdvance(
+                codePoint,
+                section,
+                glyphMap,
+                imagePositions,
+                layoutTextSize,
+                spacing,
+            );
+        }
+
+        // Ideographic characters, spaces, and word-breaking punctuation that
+        // often appear without surrounding spaces.
+        if (i < logicalInput.length() - 1) {
+            let allowsIdeographicBreak = i18n::allowsIdeographicBreaking(codePoint);
+            if (section.imageID.is_some()
+                || allowsIdeographicBreak
+                || i18n::allowsWordBreaking(codePoint))
+            {
+                let penalizableIdeographicBreak =
+                    allowsIdeographicBreak && hasServerSuggestedBreaks;
+                let nextIndex: usize = i + 1;
+                let potential_break = evaluateBreak(
+                    nextIndex,
+                    currentX,
+                    targetWidth,
+                    &potentialBreaks,
+                    calculatePenalty(
+                        codePoint,
+                        logicalInput.getCharCodeAt(nextIndex),
+                        penalizableIdeographicBreak,
+                    ),
+                    false,
+                );
+                potentialBreaks.push(potential_break);
+            }
+        }
+    }
+
+    return leastBadBreaks(&evaluateBreak(
+        logicalInput.length(),
+        currentX,
+        targetWidth,
+        &potentialBreaks,
+        0.,
+        true,
+    ));
+}
+
+fn shapeLines(
+    shaping: &mut Shaping,
+    lines: &mut Vec<TaggedString>,
+    spacing: f64,
+    lineHeight: f64,
+    textAnchor: SymbolAnchorType,
+    textJustify: TextJustifyType,
+    writingMode: WritingModeType,
+    glyphMap: &GlyphMap,
+    glyphPositions: &GlyphPositions,
+    imagePositions: &ImagePositions,
+    layoutTextSize: f64,
+    allowVerticalPlacement: bool,
+) {
+    let mut x = 0.0;
+    let mut y = Shaping::yOffset as f64;
+
+    let mut maxLineLength = 0.0;
+    let mut maxLineHeight = 0.0;
+
+    // TODO was this translated correctly?
+    let justify = if textJustify == TextJustifyType::Right {
+        1.0
+    } else {
+        if textJustify == 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 lineMaxScale = line.getMaxScale();
+        let maxLineOffset = (lineMaxScale - 1.0) * ONE_EM;
+        let mut lineOffset = 0.0;
+        shaping.positionedLines.push(PositionedLine::default());
+        let positionedLine = shaping.positionedLines.last_mut().unwrap();
+        let positionedGlyphs = &mut positionedLine.positionedGlyphs;
+
+        if (line.empty()) {
+            y += lineHeight; // Still need a line feed after empty line
+            continue;
+        }
+
+        for i in 0..line.length() {
+            let sectionIndex = line.getSectionIndex(i) as usize;
+            let section = line.sectionAt(sectionIndex);
+            let codePoint: Char16 = line.getCharCodeAt(i);
+            let mut baselineOffset = 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 verticalAdvance = ONE_EM;
+            let mut sectionScale = section.scale;
+            assert_ne!(sectionScale, 0.0);
+
+            let vertical = !(writingMode == WritingModeType::Horizontal ||
+                // Don't verticalize glyphs that have no upright orientation
+                // if vertical placement is disabled.
+                (!allowVerticalPlacement && !i18n::hasUprightVerticalOrientation(codePoint)) ||
+                // If vertical placement is ebabled, don't verticalize glyphs
+                // that are from complex text layout script, or whitespaces.
+                (allowVerticalPlacement &&
+                 (i18n::isWhitespace(codePoint) || i18n::isCharInComplexShapingScript(codePoint))));
+
+            if let Some(imageID) = &section.imageID {
+                let image = imagePositions.get(imageID);
+                if (image.is_none()) {
+                    continue;
+                }
+                let image = image.expect("is some");
+
+                shaping.iconsInText |= true;
+                let displaySize = image.displaySize();
+                metrics.width = (displaySize[0]) as u32;
+                metrics.height = (displaySize[1]) as u32;
+                metrics.left = ImagePosition::padding as i32;
+                metrics.top = -(Glyph::borderSize as i32);
+                metrics.advance = if vertical {
+                    metrics.height
+                } else {
+                    metrics.width
+                };
+                rect = image.paddedRect;
+
+                // 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.
+                sectionScale = sectionScale * ONE_EM / layoutTextSize;
+
+                // Difference between one EM and an image size.
+                // Aligns bottom of an image to a baseline level.
+                let imageOffset = ONE_EM - displaySize[1] * sectionScale as f64;
+                baselineOffset = maxLineOffset + imageOffset;
+
+                verticalAdvance = metrics.advance as f64;
+                advance = verticalAdvance;
+
+                // 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 {
+                    displaySize[0]
+                } else {
+                    displaySize[1]
+                }) * sectionScale
+                    - ONE_EM * lineMaxScale;
+                if (offset > 0.0 && offset > lineOffset) {
+                    lineOffset = offset;
+                }
+            } else {
+                let glyphPositionMap = glyphPositions.get(&section.fontStackHash); // TODO was .find
+                if (glyphPositionMap.is_none()) {
+                    continue;
+                }
+
+                let glyphPositionMap = glyphPositionMap.expect("cant be none");
+
+                let glyphPosition = glyphPositionMap.get(&codePoint);
+                if let Some(glyphPosition) = glyphPosition {
+                    rect = glyphPosition.rect;
+                    metrics = glyphPosition.metrics.clone();
+                } else {
+                    let glyphs = glyphMap.get(&section.fontStackHash);
+                    if (glyphs.is_none()) {
+                        continue;
+                    }
+                    let glyphs = glyphs.expect("cant be none");
+
+                    let glyph = glyphs.get(&codePoint);
+
+                    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.
+                baselineOffset = (lineMaxScale - sectionScale) * ONE_EM;
+            }
+
+            if (!vertical) {
+                positionedGlyphs.push(PositionedGlyph {
+                    glyph: codePoint,
+                    x,
+                    y: y + baselineOffset as f64,
+                    vertical,
+                    font: section.fontStackHash,
+                    scale: sectionScale as f64,
+                    rect,
+                    metrics,
+                    imageID: section.imageID.clone(),
+                    sectionIndex,
+                });
+                x += advance * sectionScale as f64 + spacing;
+            } else {
+                positionedGlyphs.push(PositionedGlyph {
+                    glyph: codePoint,
+                    x,
+                    y: y + baselineOffset as f64,
+                    vertical,
+                    font: section.fontStackHash,
+                    scale: sectionScale as f64,
+                    rect,
+                    metrics,
+                    imageID: section.imageID.clone(),
+                    sectionIndex,
+                });
+                x += verticalAdvance * sectionScale as f64 + spacing;
+                shaping.verticalizable |= true;
+            }
+        }
+
+        // Only justify if we placed at least one glyph
+        if (!positionedGlyphs.is_empty()) {
+            let lineLength = x - spacing; // Don't count trailing spacing
+            maxLineLength = (lineLength).max(maxLineLength);
+            justifyLine(positionedGlyphs, justify, (lineOffset) as f64);
+        }
+
+        let currentLineHeight = (lineHeight * lineMaxScale + lineOffset) as f64;
+        x = 0.0;
+        y += currentLineHeight;
+        positionedLine.lineOffset = ((lineOffset).max(maxLineOffset)) as f64;
+        maxLineHeight = (currentLineHeight).max(maxLineHeight);
+    }
+
+    let anchorAlign = AnchorAlignment::getAnchorAlignment(textAnchor);
+    let height = y - Shaping::yOffset as f64;
+    align(
+        shaping,
+        justify,
+        anchorAlign.horizontalAlign,
+        anchorAlign.verticalAlign,
+        maxLineLength,
+        maxLineHeight,
+        lineHeight,
+        height,
+        n_lines,
+    );
+
+    // Calculate the bounding box
+    shaping.top += -anchorAlign.verticalAlign * height;
+    shaping.bottom = shaping.top + height;
+    shaping.left += -anchorAlign.horizontalAlign * maxLineLength;
+    shaping.right = shaping.left + maxLineLength;
+}
+
+#[cfg(test)]
+mod test {
+    use crate::sdf::{
+        bidi::{BiDi, Char16},
+        font_stack::FontStackHasher,
+        glyph::{Glyph, GlyphMap, Glyphs, WritingModeType},
+        glyph_atlas::{GlyphPosition, GlyphPositionMap, GlyphPositions},
+        image_atlas::ImagePositions,
+        shaping::getShaping,
+        style_types::{SymbolAnchorType, TextJustifyType},
+        tagged_string::{SectionOptions, TaggedString},
+        util::constants::ONE_EM,
+    };
+
+    #[test]
+    fn Shaping_ZWSP() {
+        let mut glyphPosition = GlyphPosition::default();
+        glyphPosition.metrics.width = 18;
+        glyphPosition.metrics.height = 18;
+        glyphPosition.metrics.left = 2;
+        glyphPosition.metrics.top = -8;
+        glyphPosition.metrics.advance = 21;
+
+        let mut glyph = Glyph::default();
+        glyph.id = '中' as Char16;
+        glyph.metrics = glyphPosition.metrics;
+
+        let bidi = BiDi;
+        let fontStack = vec!["font-stack".to_string()];
+        let sectionOptions = SectionOptions::new(1.0, fontStack.clone(), None);
+        let layoutTextSize = 16.0;
+        let layoutTextSizeAtBucketZoomLevel = 16.0;
+
+        let glyphs: GlyphMap = GlyphMap::from([(
+            FontStackHasher::new(&fontStack),
+            Glyphs::from([('中' as Char16, Some(glyph))]),
+        )]);
+
+        let glyphPositions: GlyphPositions = GlyphPositions::from([(
+            FontStackHasher::new(&fontStack),
+            GlyphPositionMap::from([('中' as Char16, glyphPosition)]),
+        )]);
+        let imagePositions: ImagePositions = ImagePositions::default();
+
+        let testGetShaping = |string: &TaggedString, maxWidthInChars| {
+            return getShaping(
+                string,
+                maxWidthInChars as f64 * ONE_EM,
+                ONE_EM, // lineHeight
+                SymbolAnchorType::Center,
+                TextJustifyType::Center,
+                0.,          // spacing
+                &[0.0, 0.0], // translate
+                WritingModeType::Horizontal,
+                &bidi,
+                &glyphs,
+                &glyphPositions,
+                &imagePositions,
+                layoutTextSize,
+                layoutTextSizeAtBucketZoomLevel,
+                /*allowVerticalPlacement*/ false,
+            );
+        };
+
+        // 3 lines
+        // 中中中中中中
+        // 中中中中中中
+        // 中中
+        {
+            let string = TaggedString::new_from_raw(
+                "中中\u{200b}中中\u{200b}中中\u{200b}中中中中中中\u{200b}中中".into(),
+                sectionOptions.clone(),
+            );
+            let shaping = testGetShaping(&string, 5);
+            assert_eq!(shaping.positionedLines.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.writingMode, WritingModeType::Horizontal);
+        }
+
+        // 2 lines
+        // 中中
+        // 中
+        {
+            let string =
+                TaggedString::new_from_raw("中中\u{200b}中".into(), sectionOptions.clone());
+            let shaping = testGetShaping(&string, 1);
+            assert_eq!(shaping.positionedLines.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.writingMode, WritingModeType::Horizontal);
+        }
+
+        // 1 line
+        // 中中
+        {
+            let string = TaggedString::new_from_raw("中中\u{200b}".into(), sectionOptions.clone());
+            let shaping = testGetShaping(&string, 2);
+            assert_eq!(shaping.positionedLines.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.writingMode, WritingModeType::Horizontal);
+        }
+
+        // 5 'new' lines.
+        {
+            let string = TaggedString::new_from_raw(
+                "\u{200b}\u{200b}\u{200b}\u{200b}\u{200b}".into(),
+                sectionOptions.clone(),
+            );
+            let shaping = testGetShaping(&string, 1);
+            assert_eq!(shaping.positionedLines.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.writingMode, WritingModeType::Horizontal);
+        }
+    }
+}
diff --git a/maplibre/src/sdf/style_types.rs b/maplibre/src/sdf/style_types.rs
new file mode 100644
index 000000000..6687a3901
--- /dev/null
+++ b/maplibre/src/sdf/style_types.rs
@@ -0,0 +1,986 @@
+use std::{any::TypeId, collections::BTreeSet, marker::PhantomData};
+
+use crate::sdf::{layout::symbol_feature::SymbolGeometryTileFeature, CanonicalTileID};
+
+/// Types belonging to style
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum SymbolPlacementType {
+    Point,
+    Line,
+    LineCenter,
+}
+#[derive(Clone, Copy, PartialEq)]
+pub enum SymbolAnchorType {
+    Center,
+    Left,
+    Right,
+    Top,
+    Bottom,
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum TextJustifyType {
+    Auto,
+    Center,
+    Left,
+    Right,
+}
+#[derive(Clone, Copy, PartialEq)]
+pub enum IconTextFitType {
+    None,
+    Both,
+    Width,
+    Height,
+}
+
+#[derive(PartialOrd, Ord, PartialEq, Eq, Copy, Clone, Debug)]
+pub enum TextWritingModeType {
+    Horizontal = 0,
+    Vertical = 1,
+}
+
+pub type TextVariableAnchorType = SymbolAnchorType;
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum AlignmentType {
+    Map,
+    Viewport,
+    Auto,
+}
+#[derive(Clone, Copy, PartialEq)]
+pub enum TextTransformType {
+    None,
+    Uppercase,
+    Lowercase,
+}
+#[derive(Clone, Copy, PartialEq)]
+pub enum SymbolZOrderType {
+    Auto,
+    ViewportY,
+    Source,
+}
+#[derive(Clone, PartialEq)]
+pub struct PropertyValue<T> {
+    value: expression::Value,
+    _phandom: PhantomData<T>,
+}
+
+impl<T> Default for PropertyValue<T> {
+    fn default() -> Self {
+        // TODO
+        PropertyValue {
+            value: expression::Value::f64(0.0),
+            _phandom: Default::default(),
+        }
+    }
+}
+
+impl<T> PropertyValue<T> {
+    pub fn isUndefined(&self) -> bool {
+        // todo!()
+        false
+    }
+    pub fn isDataDriven(&self) -> bool {
+        // todo!()
+        false
+    }
+
+    pub fn isZoomant(&self) -> bool {
+        //  todo!()
+        false
+    }
+}
+
+#[derive(Clone, PartialEq)]
+pub struct PossiblyEvaluatedPropertyValue<T> {
+    value: expression::Value,
+    _phandom: PhantomData<T>,
+}
+
+impl<T> Default for PossiblyEvaluatedPropertyValue<T> {
+    fn default() -> Self {
+        // TODO
+        PossiblyEvaluatedPropertyValue {
+            value: expression::Value::f64(0.0),
+            _phandom: Default::default(),
+        }
+    }
+}
+
+impl<T> PossiblyEvaluatedPropertyValue<T> {
+    pub fn constantOr(&self, constant: T) -> T {
+        todo!()
+    }
+}
+
+pub trait LayoutProperty {
+    // type TransitionableType = std::nullptr_t;
+    type UnevaluatedType;
+    // type EvaluatorType = PropertyEvaluator<T>;
+    type PossiblyEvaluatedType;
+    type Type;
+    const IsDataDriven: bool = false;
+    const IsOverridable: bool = false;
+
+    fn name() -> &'static str;
+    fn defaultValue() -> Self::Type;
+}
+
+pub trait DataDrivenLayoutProperty {
+    // type TransitionableType = std::nullptr_t;
+    type UnevaluatedType: Default;
+    //type EvaluatorType = DataDrivenPropertyEvaluator<T>;
+    type PossiblyEvaluatedTyp: Default;
+    type Type;
+    const IsDataDriven: bool = true;
+    const IsOverridable: bool = false;
+
+    fn name() -> &'static str;
+    fn defaultValue() -> Self::Type;
+}
+
+// text
+pub struct IconAllowOverlap {}
+
+impl LayoutProperty for IconAllowOverlap {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "icon-allow-overlap";
+    }
+
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+pub struct IconAnchor {}
+
+impl DataDrivenLayoutProperty for IconAnchor {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = SymbolAnchorType;
+
+    fn name() -> &'static str {
+        return "icon-anchor";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return SymbolAnchorType::Center;
+    }
+}
+
+pub struct IconIgnorePlacement {}
+
+impl LayoutProperty for IconIgnorePlacement {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "icon-ignore-placement";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+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 {
+        return "icon-image";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return expression::Image::default();
+    }
+}
+
+pub struct IconKeepUpright {}
+
+impl LayoutProperty for IconKeepUpright {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "icon-keep-upright";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+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 {
+        return "icon-offset";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return [0.0, 0.0];
+    }
+}
+
+pub struct IconOptional {}
+
+impl LayoutProperty for IconOptional {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "icon-optional";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+pub struct IconPadding {}
+
+impl LayoutProperty for IconPadding {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "icon-padding";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return 2.0;
+    }
+}
+
+pub struct IconPitchAlignment {}
+
+impl LayoutProperty for IconPitchAlignment {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = AlignmentType;
+
+    fn name() -> &'static str {
+        return "icon-pitch-alignment";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return AlignmentType::Auto;
+    }
+}
+
+pub struct IconRotate {}
+
+impl DataDrivenLayoutProperty for IconRotate {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "icon-rotate";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 0.0;
+    }
+}
+
+pub struct IconRotationAlignment {}
+
+impl LayoutProperty for IconRotationAlignment {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = AlignmentType;
+
+    fn name() -> &'static str {
+        return "icon-rotation-alignment";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return AlignmentType::Auto;
+    }
+}
+pub struct IconSize {}
+
+impl DataDrivenLayoutProperty for IconSize {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "icon-size";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 1.0;
+    }
+}
+
+pub struct IconTextFit {}
+
+impl LayoutProperty for IconTextFit {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = IconTextFitType;
+
+    fn name() -> &'static str {
+        return "icon-text-fit";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return IconTextFitType::None;
+    }
+}
+pub struct IconTextFitPadding {}
+impl LayoutProperty for IconTextFitPadding {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = [f64; 4];
+
+    fn name() -> &'static str {
+        return "icon-text-fit-padding";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return [0.0, 0.0, 0.0, 0.0];
+    }
+}
+
+pub struct SymbolAvoidEdges {}
+
+impl LayoutProperty for SymbolAvoidEdges {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "symbol-avoid-edges";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+pub struct SymbolPlacement {}
+
+impl LayoutProperty for SymbolPlacement {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = SymbolPlacementType;
+
+    fn name() -> &'static str {
+        return "symbol-placement";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return SymbolPlacementType::Point;
+    }
+}
+
+pub struct SymbolSortKey {}
+
+impl DataDrivenLayoutProperty for SymbolSortKey {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "symbol-sort-key";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 0.0;
+    }
+}
+
+pub struct SymbolSpacing {}
+
+impl LayoutProperty for SymbolSpacing {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "symbol-spacing";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return 250.0;
+    }
+}
+
+pub struct SymbolZOrder {}
+
+impl LayoutProperty for SymbolZOrder {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = SymbolZOrderType;
+
+    fn name() -> &'static str {
+        return "symbol-z-order";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return SymbolZOrderType::Auto;
+    }
+}
+pub struct TextAllowOverlap {}
+
+impl LayoutProperty for TextAllowOverlap {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "text-allow-overlap";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+pub struct TextAnchor {}
+
+impl DataDrivenLayoutProperty for TextAnchor {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = SymbolAnchorType;
+
+    fn name() -> &'static str {
+        return "text-anchor";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return SymbolAnchorType::Center;
+    }
+}
+
+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 {
+        return "text-field";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return expression::Formatted::default();
+    }
+}
+
+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 {
+        return "text-font";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return vec![
+            "Open Sans Regular".to_string(),
+            "Arial Unicode MS Regular".to_string(),
+        ];
+    }
+}
+
+pub struct TextIgnorePlacement {}
+
+impl LayoutProperty for TextIgnorePlacement {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "text-ignore-placement";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+pub struct TextJustify {}
+
+impl DataDrivenLayoutProperty for TextJustify {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = TextJustifyType;
+
+    fn name() -> &'static str {
+        return "text-justify";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return TextJustifyType::Center;
+    }
+}
+
+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 {
+        return "text-keep-upright";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return true;
+    }
+}
+
+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 {
+        return "text-letter-spacing";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 0.0;
+    }
+}
+
+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 {
+        return "text-line-height";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return 1.2;
+    }
+}
+
+pub struct TextMaxAngle {}
+
+impl LayoutProperty for TextMaxAngle {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "text-max-angle";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return 45.0;
+    }
+}
+
+pub struct TextMaxWidth {}
+
+impl DataDrivenLayoutProperty for TextMaxWidth {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "text-max-width";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 10.0;
+    }
+}
+
+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 {
+        return "text-offset";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return [0.0, 0.0];
+    }
+}
+
+pub struct TextOptional {}
+
+impl LayoutProperty for TextOptional {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = bool;
+
+    fn name() -> &'static str {
+        return "text-optional";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return false;
+    }
+}
+
+pub struct TextPadding {}
+
+impl LayoutProperty for TextPadding {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "text-padding";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return 2.0;
+    }
+}
+
+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 {
+        return "text-pitch-alignment";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return AlignmentType::Auto;
+    }
+}
+
+pub struct TextRadialOffset {}
+
+impl DataDrivenLayoutProperty for TextRadialOffset {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "text-radial-offset";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 0.0;
+    }
+}
+
+pub struct TextRotate {}
+
+impl DataDrivenLayoutProperty for TextRotate {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "text-rotate";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 0.0;
+    }
+}
+
+pub struct TextRotationAlignment {}
+
+impl LayoutProperty for TextRotationAlignment {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = AlignmentType;
+
+    fn name() -> &'static str {
+        return "text-rotation-alignment";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return AlignmentType::Auto;
+    }
+}
+
+pub struct TextSize {}
+
+impl DataDrivenLayoutProperty for TextSize {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = f64;
+
+    fn name() -> &'static str {
+        return "text-size";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return 16.0;
+    }
+}
+
+pub struct TextTransform {}
+
+impl DataDrivenLayoutProperty for TextTransform {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedTyp = PossiblyEvaluatedPropertyValue<Self::Type>;
+    type Type = TextTransformType;
+
+    fn name() -> &'static str {
+        return "text-transform";
+    }
+    fn defaultValue() -> <Self as DataDrivenLayoutProperty>::Type {
+        return TextTransformType::None;
+    }
+}
+
+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 {
+        return "text-variable-anchor";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return Vec::new();
+    }
+}
+
+pub struct TextWritingMode {}
+
+impl LayoutProperty for TextWritingMode {
+    type UnevaluatedType = PropertyValue<Self::Type>;
+    type PossiblyEvaluatedType = Self::Type;
+    type Type = Vec<TextWritingModeType>;
+
+    fn name() -> &'static str {
+        return "text-writing-mode";
+    }
+    fn defaultValue() -> <Self as LayoutProperty>::Type {
+        return Vec::new();
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct SymbolLayoutProperties_Unevaluated;
+#[derive(Clone, Debug)]
+pub struct SymbolLayoutProperties_PossiblyEvaluated;
+
+impl SymbolLayoutProperties_PossiblyEvaluated {
+    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>()
+    }
+}
+
+#[derive(Clone)]
+pub struct SymbolLayoutProperties_Evaluated;
+
+pub mod expression {
+    use std::{
+        collections::{BTreeSet, HashMap},
+        rc::Rc,
+    };
+
+    use csscolorparser::Color;
+
+    use crate::sdf::{
+        font_stack::FontStack, layout::symbol_feature::SymbolGeometryTileFeature, CanonicalTileID,
+    };
+
+    #[derive(Clone, PartialEq)]
+    pub enum Value {
+        Color(Color),
+        f64(f64),
+        Object(HashMap<String, Value>),
+    }
+
+    // TODO
+    #[derive(Default, Clone)]
+    pub struct Image {
+        pub imageID: String,
+        pub available: bool,
+    }
+    pub struct Formatted {
+        pub sections: Vec<FormattedSection>,
+    }
+
+    impl Default for Formatted {
+        fn default() -> Self {
+            // TODO remove
+            Formatted {
+                sections: vec![FormattedSection {
+                    text: "中中中中".to_string(),
+                    image: None,
+                    fontScale: None,
+                    fontStack: None,
+                    textColor: None,
+                }],
+            }
+        }
+    }
+
+    impl Formatted {
+        fn toString() -> String {
+            todo!()
+        }
+        fn toObject() -> Value {
+            todo!()
+        }
+
+        fn empty() -> bool {
+            todo!()
+        }
+    }
+
+    impl PartialEq for Formatted {
+        fn eq(&self, other: &Self) -> bool {
+            todo!()
+        }
+    }
+
+    #[derive(Default)]
+    pub struct FormattedSection {
+        pub text: String,
+        pub image: Option<Image>,
+        pub fontScale: Option<f64>,
+        pub fontStack: Option<FontStack>,
+        pub textColor: Option<Color>,
+    }
+
+    pub const kFormattedSectionFontScale: &'static str = "font-scale";
+    pub const kFormattedSectionTextFont: &'static str = "text-font";
+    pub const kFormattedSectionTextColor: &'static str = "text-color";
+
+    // TODO
+    pub type FeatureState = Value;
+
+    pub struct EvaluationContext {
+        zoom: Option<f64>,
+        accumulated: Option<Value>,
+        feature: Rc<SymbolGeometryTileFeature>,
+        colorRampParameter: Option<f64>,
+        // Contains formatted section object, std::unordered_map<std::string, Value>.
+        formattedSection: Rc<Value>,
+        featureState: Rc<FeatureState>,
+        availableImages: Rc<BTreeSet<String>>,
+        canonical: Rc<CanonicalTileID>,
+    }
+}
+
+// TODO
+pub struct PropertyEvaluationParameters(pub f64);
+
+impl SymbolLayoutProperties_Unevaluated {
+    pub fn get_dynamic<T: DataDrivenLayoutProperty>(&self) -> T::UnevaluatedType {
+        T::UnevaluatedType::default()
+    }
+
+    pub fn evaluate(
+        &self,
+        p0: PropertyEvaluationParameters,
+    ) -> SymbolLayoutProperties_PossiblyEvaluated {
+        // TODO
+        SymbolLayoutProperties_PossiblyEvaluated
+    }
+}
+
+// TODO generated
+impl SymbolLayoutProperties_PossiblyEvaluated {
+    pub fn get<T: LayoutProperty>(&self) -> T::Type {
+        // todo!()
+        T::defaultValue()
+    }
+    pub fn set<T: LayoutProperty>(&mut self, value: T::Type) {
+        // todo!()
+    }
+
+    pub fn get_dynamic<T: DataDrivenLayoutProperty>(&self) -> T::PossiblyEvaluatedTyp {
+        T::PossiblyEvaluatedTyp::default()
+    }
+
+    pub fn evaluate<T: DataDrivenLayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::defaultValue()
+    }
+
+    pub fn evaluate_feature(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+    ) -> SymbolLayoutProperties_Evaluated {
+        //
+        SymbolLayoutProperties_Evaluated
+    }
+
+    pub fn evaluate4<T: DataDrivenLayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        availableImages: &BTreeSet<String>,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::defaultValue()
+    }
+
+    pub fn evaluate_static<T: LayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::defaultValue()
+    }
+}
+
+impl SymbolLayoutProperties_Evaluated {
+    pub fn get<T: LayoutProperty>(&self) -> T::Type {
+        //todo!()
+        T::defaultValue()
+    }
+    pub fn set<T: LayoutProperty>(&mut self, value: T::Type) {
+        // todo!()
+    }
+
+    pub fn get_dynamic<T: DataDrivenLayoutProperty>(&self) -> T::PossiblyEvaluatedTyp {
+        // todo!()
+        T::PossiblyEvaluatedTyp::default()
+    }
+
+    pub fn get_eval<T: DataDrivenLayoutProperty>(&self) -> T::Type {
+        //todo!()
+        T::defaultValue()
+    }
+
+    pub fn evaluate<T: DataDrivenLayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::defaultValue()
+    }
+
+    pub fn evaluate_static<T: LayoutProperty>(
+        &self,
+        p0: f64,
+        p1: &SymbolGeometryTileFeature,
+        p2: CanonicalTileID,
+    ) -> T::Type {
+        //todo!()
+        T::defaultValue()
+    }
+}
diff --git a/maplibre/src/sdf/tagged_string.rs b/maplibre/src/sdf/tagged_string.rs
new file mode 100644
index 000000000..657201370
--- /dev/null
+++ b/maplibre/src/sdf/tagged_string.rs
@@ -0,0 +1,315 @@
+use csscolorparser::Color;
+use widestring::{U16Str, U16String};
+
+use crate::sdf::{
+    bidi::{Char16, StyledText},
+    font_stack::{FontStack, FontStackHash, FontStackHasher},
+    util::{
+        i18n,
+        i18n::{BACKSLACK_F, BACKSLACK_V},
+    },
+};
+
+#[derive(Clone, Default)]
+pub struct SectionOptions {
+    pub scale: f64,
+    pub fontStackHash: FontStackHash,
+    pub fontStack: FontStack,
+    pub textColor: Option<Color>,
+    pub imageID: Option<String>,
+}
+impl SectionOptions {
+    pub fn from_image_id(imageID_: String) -> Self {
+        Self {
+            scale: 1.0,
+            imageID: Some(imageID_),
+            ..SectionOptions::default()
+        }
+    }
+    pub fn new(scale: f64, fontStack: FontStack, textColor: Option<Color>) -> Self {
+        Self {
+            scale,
+            fontStackHash: FontStackHasher::new(&fontStack),
+            fontStack,
+            textColor,
+            imageID: 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.
+ */
+#[derive(Clone)]
+pub struct TaggedString {
+    pub styledText: StyledText,
+    pub sections: Vec<SectionOptions>,
+    pub supportsVerticalWritingMode: 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 imageSectionID: Char16,
+}
+
+impl Default for TaggedString {
+    /// Returns an empty string
+    fn default() -> Self {
+        Self {
+            styledText: (U16String::new(), vec![]), // TODO is this correct?
+            sections: vec![],
+            supportsVerticalWritingMode: None,
+            imageSectionID: 0 as Char16, // TODO is this correct?
+        }
+    }
+}
+
+impl TaggedString {
+    pub fn new_from_raw(text_: U16String, options: SectionOptions) -> Self {
+        let text_len = text_.len();
+        Self {
+            styledText: (text_, vec![0; text_len]), // TODO is this correct?
+            sections: vec![options],
+            supportsVerticalWritingMode: None,
+            imageSectionID: 0 as Char16, // TODO is this correct?
+        }
+    }
+
+    pub fn new(styledText_: StyledText, sections_: Vec<SectionOptions>) -> Self {
+        Self {
+            styledText: styledText_,
+            sections: sections_,
+            supportsVerticalWritingMode: None,
+            imageSectionID: 0 as Char16, // TODO is this correct?
+        }
+    }
+
+    pub fn length(&self) -> usize {
+        return self.styledText.0.len();
+    }
+
+    pub fn sectionCount(&self) -> usize {
+        return self.sections.len();
+    }
+
+    pub fn empty(&self) -> bool {
+        return self.styledText.0.is_empty();
+    }
+
+    pub fn getSection(&self, index: usize) -> &SectionOptions {
+        return &self.sections[self.styledText.1[index] as usize]; // TODO Index does not honor encoding, fine? previously it was .at()
+    }
+
+    pub fn getCharCodeAt(&self, index: usize) -> u16 {
+        return self.styledText.0.as_slice()[index];
+    }
+
+    pub fn rawText(&self) -> &U16String {
+        return &self.styledText.0;
+    }
+
+    pub fn getStyledText(&self) -> &StyledText {
+        return &self.styledText;
+    }
+
+    pub fn addTextSection(
+        &mut self,
+        sectionText: &U16String,
+        scale: f64,
+        fontStack: FontStack,
+        textColor: Option<Color>,
+    ) {
+        self.styledText.0.push(sectionText);
+        self.sections
+            .push(SectionOptions::new(scale, fontStack, textColor));
+        self.styledText
+            .1
+            .resize(self.styledText.0.len(), (self.sections.len() - 1) as u8);
+        self.supportsVerticalWritingMode = None;
+    }
+
+    pub fn addImageSection(&mut self, imageID: String) {
+        let nextImageSectionCharCode = self.getNextImageSectionCharCode();
+
+        if let Some(nextImageSectionCharCode) = nextImageSectionCharCode {
+            self.styledText
+                .0
+                .push(U16Str::from_slice(&[nextImageSectionCharCode])); // TODO is this correct?
+            self.sections.push(SectionOptions::from_image_id(imageID));
+            self.styledText
+                .1
+                .resize(self.styledText.0.len(), (self.sections.len() - 1) as u8);
+        } else {
+            log::warn!("Exceeded maximum number of images in a label.");
+        }
+    }
+
+    pub fn sectionAt(&self, index: usize) -> &SectionOptions {
+        return &self.sections[index];
+    }
+
+    pub fn getSections(&self) -> &Vec<SectionOptions> {
+        return &self.sections;
+    }
+
+    pub fn getSectionIndex(&self, characterIndex: usize) -> u8 {
+        return self.styledText.1[characterIndex]; // TODO Index does not honor encoding, fine? previously it was .at()
+    }
+
+    pub fn getMaxScale(&self) -> f64 {
+        let mut maxScale: f64 = 0.0;
+        for i in 0..self.styledText.0.len() {
+            maxScale = maxScale.max(self.getSection(i).scale)
+        }
+        return maxScale;
+    }
+
+    const WHITESPACE_CHARS: &'static [Char16] = &[
+        ' ' as Char16,
+        '\t' as Char16,
+        '\n' as Char16,
+        BACKSLACK_V as Char16,
+        BACKSLACK_F as Char16,
+        '\r' as Char16,
+    ];
+
+    pub fn trim(&mut self) {
+        let beginningWhitespace: Option<usize> = self
+            .styledText
+            .0
+            .as_slice()
+            .iter()
+            .position(|c| !Self::WHITESPACE_CHARS.contains(c));
+
+        if let Some(beginningWhitespace) = beginningWhitespace {
+            let trailingWhitespace: usize = self
+                .styledText
+                .0
+                .as_slice()
+                .iter()
+                .rposition(|c| !Self::WHITESPACE_CHARS.contains(c))
+                .expect("there is a whitespace char")
+                + 1;
+
+            self.styledText.0 =
+                U16String::from(&self.styledText.0[beginningWhitespace..trailingWhitespace]); // TODO write test for this
+            self.styledText.1 =
+                Vec::from(&self.styledText.1[beginningWhitespace..trailingWhitespace]);
+        } else {
+            // Entirely whitespace
+            self.styledText.0.clear();
+            self.styledText.1.clear();
+        }
+    }
+
+    pub fn verticalizePunctuation(&mut self) {
+        // Relies on verticalization changing characters in place so that style indices don't need updating
+        self.styledText.0 = i18n::verticalizePunctuation_str(&self.styledText.0);
+    }
+    pub fn allowsVerticalWritingMode(&mut self) -> bool {
+        if (self.supportsVerticalWritingMode.is_none()) {
+            let new_value = i18n::allowsVerticalWritingMode(self.rawText());
+            self.supportsVerticalWritingMode = Some(new_value);
+            return new_value;
+        }
+        return self
+            .supportsVerticalWritingMode
+            .expect("supportsVerticalWritingMode mut be set");
+    }
+}
+
+impl TaggedString {
+    fn getNextImageSectionCharCode(&mut self) -> Option<Char16> {
+        if (self.imageSectionID == 0) {
+            self.imageSectionID = PUAbegin;
+            return Some(self.imageSectionID);
+        }
+
+        self.imageSectionID += 1;
+        if (self.imageSectionID > PUAend) {
+            return None;
+        }
+
+        return Some(self.imageSectionID);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use widestring::U16String;
+
+    use crate::sdf::{
+        bidi::Char16,
+        tagged_string::{SectionOptions, TaggedString},
+        util::i18n::BACKSLACK_V,
+    };
+
+    #[test]
+    fn TaggedString_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.rawText(), &U16String::from("trim that and not this"));
+
+        let mut twoSections = TaggedString::default();
+        twoSections.addTextSection(&" \t\ntrim that".into(), 1.5, vec![], None);
+        twoSections.addTextSection(&" and not this  \n\t".into(), 0.5, vec![], None);
+
+        twoSections.trim();
+        assert_eq!(
+            twoSections.rawText(),
+            &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.rawText(), &U16String::from(""));
+
+        let mut noTrim =
+            TaggedString::new_from_raw("no trim!".into(), SectionOptions::new(1.0, vec![], None));
+        noTrim.trim();
+        assert_eq!(noTrim.rawText(), &U16String::from("no trim!"));
+    }
+    #[test]
+    fn TaggedString_ImageSections() {
+        let mut string = TaggedString::new_from_raw(U16String::new(), SectionOptions::default());
+        string.addImageSection("image_name".to_string());
+        assert_eq!(string.rawText(), &U16String::from("\u{E000}"));
+        assert!(string.getSection(0).imageID.is_some());
+        assert_eq!(
+            string.getSection(0).imageID.as_ref().unwrap(),
+            &"image_name".to_string()
+        );
+
+        let mut maxSections = TaggedString::default();
+        for i in 0..6401 {
+            maxSections.addImageSection(i.to_string());
+        }
+
+        assert_eq!(maxSections.getSections().len(), 6400);
+        assert_eq!(maxSections.getCharCodeAt(0), '\u{E000}' as Char16);
+        assert_eq!(maxSections.getCharCodeAt(6399), '\u{F8FF}' as Char16);
+    }
+}
diff --git a/maplibre/src/sdf/tessellation.rs b/maplibre/src/sdf/tessellation.rs
new file mode 100644
index 000000000..a9ef82603
--- /dev/null
+++ b/maplibre/src/sdf/tessellation.rs
@@ -0,0 +1,281 @@
+//! Tessellation for lines and polygons is implemented here.
+
+use std::collections::HashMap;
+use csscolorparser::Color;
+use geozero::{ColumnValue, FeatureProcessor, GeomProcessor, PropertyProcessor};
+use geozero::geo_types::GeoWriter;
+use lyon::{
+    geom::euclid::{Box2D, Point2D},
+    tessellation::{
+        geometry_builder::MaxIndex, BuffersBuilder, FillOptions, FillTessellator, VertexBuffers,
+    },
+};
+
+use crate::{
+    render::shaders::ShaderSymbolVertex,
+    sdf::{
+        text::{Anchor, Glyph, GlyphSet, SymbolVertexBuilder},
+        Feature, TileSpace,
+    },
+};
+
+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>;
+
+/// 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(|glyph| StringGlyph::Glyph(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 let Some(_) = self.current_origin {
+            //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..e26bdce7f
--- /dev/null
+++ b/maplibre/src/sdf/tessellation_new.rs
@@ -0,0 +1,261 @@
+//! Tessellation for lines and polygons is implemented here.
+
+use std::collections::HashMap;
+use csscolorparser::Color;
+use geo_types::Geometry;
+use geozero::{ColumnValue, FeatureProcessor, GeomProcessor, PropertyProcessor};
+use geozero::geo_types::GeoWriter;
+use lyon::{
+    geom::euclid::{Box2D, Point2D},
+    tessellation::{
+        geometry_builder::MaxIndex, VertexBuffers,
+    },
+};
+
+use crate::{
+    sdf::{
+        text::{Anchor, Glyph, GlyphSet, SymbolVertexBuilder},
+        Feature, TileSpace,
+    },
+};
+use crate::euclid::{Rect, Size2D};
+use crate::io::geometry_index::IndexedGeometry;
+use crate::render::shaders::ShaderSymbolVertexNew;
+use crate::sdf::bidi::Char16;
+use crate::sdf::{CanonicalTileID, MapMode, OverscaledTileID};
+use crate::sdf::font_stack::FontStackHasher;
+use crate::sdf::geometry_tile_data::{GeometryCoordinates, SymbolGeometryTileLayer};
+use crate::sdf::glyph::{GlyphDependencies, GlyphMap, GlyphMetrics};
+use crate::sdf::glyph_atlas::{GlyphAtlas, GlyphPosition, GlyphPositionMap, GlyphPositions};
+use crate::sdf::image::ImageMap;
+use crate::sdf::image_atlas::ImagePositions;
+use crate::sdf::layout::layout::{BucketParameters, LayerTypeInfo, LayoutParameters};
+use crate::sdf::layout::symbol_feature::{SymbolGeometryTileFeature, VectorGeometryTileFeature};
+use crate::sdf::layout::symbol_layout::{FeatureIndex, LayerProperties, SymbolLayer, SymbolLayout};
+use crate::sdf::style_types::SymbolLayoutProperties_Unevaluated;
+
+
+/// 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 TextTessellatorNew<I> {
+    geo_writer: GeoWriter,
+
+    // output
+    pub quad_buffer: VertexBuffers<ShaderSymbolVertexNew, I>,
+    pub features: Vec<Feature>,
+
+    // iteration variables
+    current_index: usize,
+    current_text: Option<String>,
+    current_origin: Option<Box2D<f32, TileSpace>>,
+}
+
+impl<I> TextTessellatorNew<I> {
+    pub fn finish() {
+
+        let fontStack = vec![
+            "Open Sans Regular".to_string(),
+            "Arial Unicode MS Regular".to_string(),
+        ];
+
+        // load glyph/image data
+
+        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();
+
+        // layouting
+
+
+        let mut glyphDependencies = GlyphDependencies::new();
+
+        let tile_id = OverscaledTileID {
+            canonical: CanonicalTileID { x: 0, y: 0, z: 0 },
+            overscaledZ: 0,
+        };
+        let mut parameters = BucketParameters {
+            tileID: tile_id,
+            mode: MapMode::Continuous,
+            pixelRatio: 1.0,
+            layerType: 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 {
+                bucketParameters: &mut parameters.clone(),
+                glyphDependencies: &mut glyphDependencies,
+                imageDependencies: &mut Default::default(),
+                availableImages: &mut Default::default(),
+            },
+        ).unwrap();
+
+        layout.prepareSymbols(&glyphs, &glyphPositions, &empty_image_map, &image_positions);
+
+        let mut output = HashMap::new();
+        layout.createBucket(
+            image_positions,
+            Box::new(FeatureIndex),
+            &mut output,
+            false,
+            false,
+            &tile_id.canonical,
+        );
+
+    }
+}
+
+impl<I> Default for TextTessellatorNew<I>
+{
+    fn default() -> Self {
+        Self {
+            geo_writer: Default::default(),
+            quad_buffer: VertexBuffers::new(),
+            features: vec![],
+            current_index: 0,
+            current_text: None,
+            current_origin: None,
+        }
+    }
+}
+
+impl<I> GeomProcessor for TextTessellatorNew<I> {
+    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<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> PropertyProcessor
+for TextTessellatorNew<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 TextTessellatorNew<I>
+{
+    fn feature_end(&mut self, _idx: u64) -> geozero::error::Result<()> {
+        let geometry = self.geo_writer.take_geometry();
+
+        match geometry {
+            Some(Geometry::Point(point)) => self.geometries.push(
+
+            ),
+            Some(Geometry::Polygon(polygon)) => self.geometries.push(
+
+            ),
+            Some(Geometry::LineString(linestring)) => self.geometries.push(
+
+            ),
+            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")
+            }
+        };
+
+
+    }
+}
\ No newline at end of file
diff --git a/maplibre/src/sdf/text.rs b/maplibre/src/sdf/text.rs
new file mode 100644
index 000000000..3fed48ea5
--- /dev/null
+++ b/maplibre/src/sdf/text.rs
@@ -0,0 +1,189 @@
+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 {
+    codepoint: UnicodePoint,
+    width: u32,
+    height: u32,
+    pub left_bearing: i32,
+    pub top_bearing: i32,
+    h_advance: u32,
+    /// x origin coordinate within the packed texture
+    tex_origin_x: u32,
+    /// y origin coordinate within the packed texture
+    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..8ed985d26
--- /dev/null
+++ b/maplibre/src/sdf/upload_system.rs
@@ -0,0 +1,127 @@
+//! 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,
+                ..
+            }) = 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().unwrap().indices.end)
+                .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/sdf/util/constants.rs b/maplibre/src/sdf/util/constants.rs
new file mode 100644
index 000000000..2ae762071
--- /dev/null
+++ b/maplibre/src/sdf/util/constants.rs
@@ -0,0 +1,2 @@
+// 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/sdf/util/geo.rs b/maplibre/src/sdf/util/geo.rs
new file mode 100644
index 000000000..e7dc17cf3
--- /dev/null
+++ b/maplibre/src/sdf/util/geo.rs
@@ -0,0 +1,3 @@
+use geo_types::LineString;
+
+pub type ScreenLineString = LineString;
diff --git a/maplibre/src/sdf/util/i18n.rs b/maplibre/src/sdf/util/i18n.rs
new file mode 100644
index 000000000..4e9bd741e
--- /dev/null
+++ b/maplibre/src/sdf/util/i18n.rs
@@ -0,0 +1,116 @@
+use widestring::U16String;
+
+use crate::sdf::bidi::Char16;
+
+pub fn allowsWordBreaking(chr: Char16) -> bool {
+    return (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/* en dash */);
+}
+
+pub fn charAllowsLetterSpacing(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+pub fn allowsLetterSpacing(string: &U16String) -> bool {
+    return false;
+    todo!()
+}
+
+pub fn allowsIdeographicBreaking_str(string: &U16String) -> bool {
+    return false;
+    todo!()
+}
+
+pub fn allowsIdeographicBreaking(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+pub fn allowsFixedWidthGlyphGeneration(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+pub fn allowsVerticalWritingMode(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.
+
+pub fn hasUprightVerticalOrientation(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+pub fn hasNeutralVerticalOrientation(chr: Char16) -> bool {
+    return false;
+    todo!()
+}
+
+pub fn hasRotatedVerticalOrientation(chr: Char16) -> bool {
+    return !(hasUprightVerticalOrientation(chr) || hasNeutralVerticalOrientation(chr));
+}
+
+// Replaces "horizontal" with "vertical" punctuation in place
+// Does not re-order or change length of string
+// (TaggedString::verticalizePunctuation depends on this behavior)
+pub fn verticalizePunctuation_str(input: &U16String) -> U16String {
+    return input.clone();
+    todo!()
+}
+
+pub fn verticalizePunctuation(chr: Char16) -> Char16 {
+    return 0;
+    todo!()
+}
+
+pub fn charInSupportedScript(chr: Char16) -> bool {
+    return true;
+    todo!()
+}
+
+pub fn isStringInSupportedScript(input: &str) -> bool {
+    let u16string = U16String::from(input); // TODO: verify if this is correct
+    for chr in u16string.as_slice() {
+        if (!charInSupportedScript(*chr)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+pub fn isCharInComplexShapingScript(chr: Char16) -> bool {
+    return false;
+}
+
+pub const BACKSLACK_V: Char16 = '\u{000B}' as Char16;
+pub const BACKSLACK_F: Char16 = '\u{000C}' as Char16;
+
+pub fn isWhitespace(chr: Char16) -> bool {
+    // TODO verify that his is correct \v and \f where not available
+    return 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/sdf/util/math.rs b/maplibre/src/sdf/util/math.rs
new file mode 100644
index 000000000..fe4d85699
--- /dev/null
+++ b/maplibre/src/sdf/util/math.rs
@@ -0,0 +1,46 @@
+use std::f64::consts::PI;
+
+use crate::euclid::Vector2D;
+
+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;
+    return Vector2D::new(x, y);
+}
+
+/**
+ * @brief Converts degrees to radians
+ *
+ * @param deg Degrees as float.
+ * @return Radians as float.
+ */
+pub fn deg2radf(deg: f64) -> f64 {
+    return deg * PI / 180.0;
+}
+
+pub fn perp<U>(a: &Vector2D<f64, U>) -> Vector2D<f64, U> {
+    return Vector2D::new(-a.y, a.x);
+}
+
+pub trait MinMax<T> {
+    fn max_value(self) -> T;
+    fn min_value(self) -> T;
+}
+
+impl MinMax<f64> for [f64; 4] {
+    fn max_value(self) -> f64 {
+        *self
+            .iter()
+            .max_by(|a, b| a.total_cmp(b))
+            .expect("array is not empty")
+    }
+
+    fn min_value(self) -> f64 {
+        *self
+            .iter()
+            .min_by(|a, b| a.total_cmp(b))
+            .expect("array is not empty")
+    }
+}
diff --git a/maplibre/src/sdf/util/mod.rs b/maplibre/src/sdf/util/mod.rs
new file mode 100644
index 000000000..11d1d6a9a
--- /dev/null
+++ b/maplibre/src/sdf/util/mod.rs
@@ -0,0 +1,66 @@
+use std::{
+    hash::{DefaultHasher, Hash, Hasher},
+    ops::Range,
+};
+
+pub mod constants;
+pub mod geo;
+pub mod i18n;
+pub mod math;
+
+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;
+}
+
+pub fn hash<T: Hash>(args: &[T]) -> u64 {
+    let mut seed = 0;
+
+    for arg in args {
+        hash_combine(&mut seed, arg);
+    }
+    return seed;
+}
+
+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))
+}
+
+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::sdf::util::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/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 991efb8d9..641ec3aac 100644
--- a/maplibre/src/vector/process_vector.rs
+++ b/maplibre/src/vector/process_vector.rs
@@ -12,10 +12,15 @@ 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, ShaderVertex},
+    sdf::{tessellation::TextTessellator, Feature},
+    style::layer::{LayerPaint, StyleLayer},
+    vector::{
+        tessellation::{IndexDataType, OverAlignedVertexBuffer, ZeroTessellator},
+        transferables::{
+            LayerIndexed, LayerMissing, LayerTessellated, SymbolLayerTessellated, TileTessellated,
+            VectorTransferables,
+        },
     },
 };
 
@@ -32,7 +37,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 +45,88 @@ 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;
-        }
-
-        let mut tessellator = ZeroTessellator::<IndexDataType>::default();
-        if let Err(e) = layer.process(&mut tessellator) {
-            context.layer_missing(coords, layer_name)?;
-
-            tracing::error!("layer {layer_name} at {coords} tesselation failed {e:?}");
+    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();
+
+                match paint {
+                    LayerPaint::Line(_) | LayerPaint::Fill(_) => {
+                        let mut tessellator = ZeroTessellator::<IndexDataType>::default();
+
+                        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();
+
+                        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.symbol_layer_tesselation_finished(
+                                coords,
+                                tessellator.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 +135,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 +194,20 @@ 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>,
+        features: Vec<Feature>,
+        layer_data: tile::Layer,
+    ) -> Result<(), ProcessVectorError> {
+        self.context
+            .send(T::SymbolLayerTessellated::build_from(
+                *coords, 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 c2207a442..185de8054 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(<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..f16412049 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::<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());
+        }
+    }
+}
+
 /// 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..097dd5146 100644
--- a/maplibre/src/vector/transferables.rs
+++ b/maplibre/src/vector/transferables.rs
@@ -8,9 +8,12 @@ use crate::{
         apc::{IntoMessage, Message, MessageTag},
         geometry_index::TileIndex,
     },
-    render::ShaderVertex,
-    tessellation::{IndexDataType, OverAlignedVertexBuffer},
-    vector::{AvailableVectorLayerData, MissingVectorLayerData},
+    render::{shaders::ShaderSymbolVertex, ShaderVertex},
+    sdf::{Feature, SymbolLayerData},
+    vector::{
+        tessellation::{IndexDataType, OverAlignedVertexBuffer},
+        AvailableVectorLayerBucket, MissingVectorLayerBucket,
+    },
 };
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
@@ -18,7 +21,8 @@ pub enum VectorMessageTag {
     TileTessellated = 1,
     LayerMissing = 2,
     LayerTessellated = 3,
-    LayerIndexed = 4,
+    SymbolLayerTessellated = 4,
+    LayerIndexed = 10,
 }
 
 impl MessageTag for VectorMessageTag {
@@ -48,7 +52,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 +71,26 @@ 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>,
+        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 +169,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 +178,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 +186,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 +225,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 +235,62 @@ impl LayerTessellated for DefaultLayerTesselated {
     }
 }
 
+pub struct DefaultSymbolLayerTessellated {
+    pub coords: WorldTileCoords,
+    pub buffer: OverAlignedVertexBuffer<ShaderSymbolVertex, 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>,
+        features: Vec<Feature>,
+        layer_data: Layer,
+    ) -> Self {
+        Self {
+            coords,
+            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,
+            features: self.features,
+        }
+    }
+}
+
 pub struct DefaultLayerIndexed {
     coords: WorldTileCoords,
     index: TileIndex,
@@ -251,6 +330,7 @@ pub trait VectorTransferables: Copy + Clone + 'static {
     type TileTessellated: TileTessellated;
     type LayerMissing: LayerMissing;
     type LayerTessellated: LayerTessellated;
+    type SymbolLayerTessellated: SymbolLayerTessellated;
     type LayerIndexed: LayerIndexed;
 }
 
@@ -260,6 +340,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 efa21f797..04df33ee2 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..75654baa8 100644
--- a/web/src/platform/singlethreaded/transferables.rs
+++ b/web/src/platform/singlethreaded/transferables.rs
@@ -14,11 +14,12 @@ use maplibre::{
         AvailableRasterLayerData, LayerRaster, LayerRasterMissing, MissingRasterLayerData,
         RasterTransferables,
     },
-    render::ShaderVertex,
+    render::{shaders::ShaderSymbolVertex, ShaderVertex},
+    sdf::SymbolLayerData,
     tile::Layer,
     vector::{
-        AvailableVectorLayerData, LayerIndexed, LayerMissing, LayerTessellated,
-        MissingVectorLayerData, TileTessellated, VectorTransferables,
+        AvailableVectorLayerBucket, LayerIndexed, LayerMissing, LayerTessellated,
+        MissingVectorLayerBucket, SymbolLayerTessellated, TileTessellated, VectorTransferables,
     },
 };
 
@@ -26,7 +27,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 +70,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 +167,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 +245,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 +256,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 +391,98 @@ 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>,
+        feature_indices: Vec<u32>,
+        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);
+        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);
+        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),
+            feature_indices,
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct FlatTransferables;
 
@@ -388,6 +490,7 @@ impl VectorTransferables for FlatTransferables {
     type TileTessellated = FlatBufferTransferable;
     type LayerMissing = FlatBufferTransferable;
     type LayerTessellated = FlatBufferTransferable;
+    type SymbolLayerTessellated = FlatBufferTransferable;
     type LayerIndexed = FlatBufferTransferable;
 }