diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 645ee232..591bb1d5 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -20,7 +20,7 @@ jobs:
     steps:
     - uses: dtolnay/rust-toolchain@master
       with:
-        toolchain: 1.75.0
+        toolchain: 1.76.0
         components: clippy, rustfmt
     - uses: actions/checkout@v3
     - uses: actions/cache@v3
@@ -31,7 +31,7 @@ jobs:
           ~/.cargo/registry/cache/
           ~/.cargo/git/db/
           target/
-        key: ${{ runner.os }}-cargo-build-1.75.0-${{ hashFiles('**/Cargo.toml') }}
+        key: ${{ runner.os }}-cargo-build-1.76.0-${{ hashFiles('**/Cargo.toml') }}
     - name: Install alsa and udev
       run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
       if: runner.os == 'linux'
diff --git a/Cargo.toml b/Cargo.toml
index dabdad80..100044e4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,11 +13,14 @@ exclude = ["assets/*", "screenshots/*", "book"]
 [workspace]
 members = ["kayak_ui_macros", "kayak_font"]
 
+[features]
+svg = ["dep:bevy_svg"]
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { version = "0.12", default-features = false, features = ["bevy_render", "bevy_asset", "bevy_winit", "bevy_core_pipeline"] }
-bevy_svg = { version="0.12", default-features = false }
+bevy = { version = "0.13", default-features = false, features = ["bevy_render", "bevy_asset", "bevy_core_pipeline"] }
+bevy_svg = { git = "https://github.com/arnfaldur/bevy_svg", rev="53a53e5af050a7b5b236068546be46c5729674e3", default-features = false, optional = true }
 bitflags = "1.3.2"
 bytemuck = "1.12"
 dashmap = "5.4"
@@ -33,11 +36,12 @@ reorder = "2.1"
 resources = "1.1"
 usvg = "0.27"
 uuid = { version = "1.3", features = ["v4"] }
+smol_str = {version = "0.2", default-features = false}
 
 [dev-dependencies]
 fastrand = "1.8"
-bevy-inspector-egui = "0.21"
-bevy = { version = "0.12", default-features = true }
+bevy-inspector-egui = "0.23"
+bevy = { version = "0.13", default-features = true }
 
 [[example]]
 name = "tabs"
@@ -47,5 +51,21 @@ path = "examples/tabs/tabs.rs"
 name = "todo"
 path = "examples/todo/todo.rs"
 
+[[example]]
+name = "svg"
+path = "examples/svg.rs"
+test = false
+doc = false
+bench = false
+required-features = ["svg"]
+
+[[example]]
+name = "accordion"
+path = "examples/accordion.rs"
+test = false
+doc = false
+bench = false
+required-features = ["svg"]
+
 [package.metadata.docs.rs]
 features = ["bevy/x11"]
diff --git a/examples/avsb.rs b/examples/avsb.rs
index 836f846f..544df759 100644
--- a/examples/avsb.rs
+++ b/examples/avsb.rs
@@ -202,7 +202,10 @@ fn startup(
     commands.spawn((widget_context, EventDispatcher::default()));
 }
 
-fn swap(input: Res<Input<KeyCode>>, mut query: Query<&mut AvsBState, Without<PreviousWidget>>) {
+fn swap(
+    input: Res<ButtonInput<KeyCode>>,
+    mut query: Query<&mut AvsBState, Without<PreviousWidget>>,
+) {
     if input.just_pressed(KeyCode::Space) {
         for mut avsb in query.iter_mut() {
             avsb.is_a = !avsb.is_a;
diff --git a/examples/bevy_scene.rs b/examples/bevy_scene.rs
index a33793f8..705938fc 100644
--- a/examples/bevy_scene.rs
+++ b/examples/bevy_scene.rs
@@ -38,7 +38,7 @@ struct WorldCamera;
 /// to filter out clicks that occur over the UI
 fn set_active_tile_target(
     mut tile: Query<&mut ActiveTile>,
-    cursor: Res<Input<MouseButton>>,
+    cursor: Res<ButtonInput<MouseButton>>,
     event_context: Query<&EventDispatcher, With<GameUI>>,
     camera_transform: Query<&GlobalTransform, With<WorldCamera>>,
     window: Query<&Window, With<PrimaryWindow>>,
diff --git a/examples/demo.rs b/examples/demo.rs
index d4f15421..0b235180 100644
--- a/examples/demo.rs
+++ b/examples/demo.rs
@@ -57,7 +57,7 @@ fn startup(mut commands: Commands) {
 // Note this example shows prop changing not state changing which is quite different.
 // For state changes please see simple_state example.
 fn update_resource(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut MyWidget, Without<PreviousWidget>>,
 ) {
     if keyboard_input.just_pressed(KeyCode::Space) {
diff --git a/examples/main_menu.rs b/examples/main_menu.rs
index 3e2625db..410a5a53 100644
--- a/examples/main_menu.rs
+++ b/examples/main_menu.rs
@@ -22,7 +22,7 @@ impl Default for MenuButtonBundle {
             button: Default::default(),
             styles: KStyle {
                 bottom: Units::Pixels(20.0).into(),
-                cursor: KCursorIcon(CursorIcon::Hand).into(),
+                cursor: KCursorIcon(CursorIcon::Pointer).into(),
                 ..Default::default()
             },
             on_event: OnEvent::default(),
diff --git a/examples/render_target.rs b/examples/render_target.rs
index 1d5bfec1..d1517509 100644
--- a/examples/render_target.rs
+++ b/examples/render_target.rs
@@ -62,11 +62,10 @@ fn startup(
             camera: Camera {
                 order: -1,
                 target: RenderTarget::Image(image_handle.clone()),
+                clear_color: ClearColorConfig::None,
                 ..Camera::default()
             },
-            camera_2d: Camera2d {
-                clear_color: bevy::core_pipeline::clear_color::ClearColorConfig::Default,
-            },
+            camera_2d: Camera2d,
             ..Default::default()
         })
         .insert(CameraUIKayak)
@@ -107,7 +106,7 @@ fn startup(
     });
 
     let cube_size = 4.0;
-    let cube_handle = meshes.add(Mesh::from(shape::Box::new(cube_size, cube_size, cube_size)));
+    let cube_handle = meshes.add(Mesh::from(Cuboid::from_size(Vec3::splat(cube_size))));
 
     // This material has the texture that has been rendered.
     let material_handle = materials.add(StandardMaterial {
@@ -169,7 +168,7 @@ fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Ma
 
 fn depsawn_ui(
     mut commands: Commands,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
     ui_query: Query<(Entity, &KayakRootContext), With<MainUI>>,
 ) {
     if keyboard_input.pressed(KeyCode::Escape) {
diff --git a/examples/test_no_startup.rs b/examples/test_no_startup.rs
index 5652a8c8..1ac72db1 100644
--- a/examples/test_no_startup.rs
+++ b/examples/test_no_startup.rs
@@ -45,7 +45,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_plugins((KayakContextPlugin, KayakWidgets))
-        .add_state::<GameState>()
+        .init_state::<GameState>()
         .add_systems(OnEnter(GameState::First), first_sys)
         .add_systems(OnEnter(GameState::Second), second_sys)
         .run();
diff --git a/examples/text.rs b/examples/text.rs
index 6828285c..e87b8b7e 100644
--- a/examples/text.rs
+++ b/examples/text.rs
@@ -100,7 +100,7 @@ fn startup(
     commands.spawn((widget_context, EventDispatcher::default()));
 }
 
-fn update_resource(keyboard_input: Res<Input<KeyCode>>, mut my_resource: ResMut<MyResource>) {
+fn update_resource(keyboard_input: Res<ButtonInput<KeyCode>>, mut my_resource: ResMut<MyResource>) {
     if keyboard_input.just_pressed(KeyCode::Space) {
         my_resource.0 += 1;
     }
diff --git a/examples/texture_atlas.rs b/examples/texture_atlas.rs
index 1ae3dd93..01ce4d47 100644
--- a/examples/texture_atlas.rs
+++ b/examples/texture_atlas.rs
@@ -18,8 +18,7 @@ fn startup(
     let tile_size = 16;
     let columns = 272 / tile_size;
     let rows = 128 / tile_size;
-    let atlas = bevy::sprite::TextureAtlas::from_grid(
-        image_handle.clone(),
+    let atlas = bevy::sprite::TextureAtlasLayout::from_grid(
         bevy::prelude::Vec2::splat(tile_size as f32),
         columns,
         rows,
diff --git a/kayak_font/Cargo.toml b/kayak_font/Cargo.toml
index 343ed16f..3354ddd3 100644
--- a/kayak_font/Cargo.toml
+++ b/kayak_font/Cargo.toml
@@ -28,10 +28,10 @@ image = "0.24"
 # Provides UAX #14 line break segmentation
 xi-unicode = "0.3"
 
-bevy = { version = "0.12", optional = true, default-features = false, features = ["bevy_asset", "bevy_render", "bevy_core_pipeline"] }
+bevy = { version = "0.13", optional = true, default-features = false, features = ["bevy_asset", "bevy_render", "bevy_core_pipeline"] }
 
 [dev-dependencies]
-bevy = { version = "0.12" }
+bevy = { version = "0.13", default-features = false }
 bytemuck = "1.12.0"
 
 [package.metadata.docs.rs]
diff --git a/kayak_font/src/bevy/renderer/extract.rs b/kayak_font/src/bevy/renderer/extract.rs
index faf7e856..bcb254c3 100644
--- a/kayak_font/src/bevy/renderer/extract.rs
+++ b/kayak_font/src/bevy/renderer/extract.rs
@@ -46,6 +46,7 @@ pub(crate) fn extract_fonts(
                 let id = asset_server.get_id_handle(*id).unwrap();
                 changed_assets.insert(id.clone_weak());
             }
+            AssetEvent::Unused { id: _ } => {}
         }
     }
 
diff --git a/kayak_font/src/ttf/loader.rs b/kayak_font/src/ttf/loader.rs
index 4f2930eb..1b40b063 100644
--- a/kayak_font/src/ttf/loader.rs
+++ b/kayak_font/src/ttf/loader.rs
@@ -4,7 +4,10 @@ use bevy::{
         io::{AssetSourceBuilders, Reader},
         AssetLoader, AssetServer, AsyncReadExt, LoadContext,
     },
-    render::render_resource::{Extent3d, TextureFormat},
+    render::{
+        render_asset::RenderAssetUsages,
+        render_resource::{Extent3d, TextureFormat},
+    },
     utils::{BoxedFuture, HashMap},
 };
 
@@ -263,6 +266,7 @@ impl AssetLoader for TTFLoader {
                 bevy::render::render_resource::TextureDimension::D2,
                 image_bytes,
                 TextureFormat::Rgba8Unorm,
+                RenderAssetUsages::all(),
             );
             image.reinterpret_stacked_2d_as_array(char_count);
             let labeled_asset = load_context.begin_labeled_asset();
diff --git a/src/camera/mod.rs b/src/camera/mod.rs
index 8fa76a20..7c007cf7 100644
--- a/src/camera/mod.rs
+++ b/src/camera/mod.rs
@@ -7,11 +7,11 @@ use bevy::{
 #[derive(Component, Default, Debug, Clone, Copy)]
 pub struct CameraUIKayak;
 impl ExtractComponent for CameraUIKayak {
-    type Query = &'static Self;
-    type Filter = With<Camera>;
+    type QueryData = &'static Self;
+    type QueryFilter = With<Camera>;
     type Out = CameraUIKayak;
 
-    fn extract_component(item: QueryItem<Self::Query>) -> Option<Self::Out> {
+    fn extract_component(item: QueryItem<Self::QueryData>) -> Option<Self::Out> {
         Some(*item)
     }
 }
diff --git a/src/event.rs b/src/event.rs
index c85dfe8b..67875301 100644
--- a/src/event.rs
+++ b/src/event.rs
@@ -55,8 +55,8 @@ impl KEvent {
         Self {
             target,
             current_target: target,
-            event_type,
             should_propagate: event_type.propagates(),
+            event_type,
             default_prevented: false,
             on_change_systems: Vec::new(),
         }
@@ -108,7 +108,7 @@ impl KEvent {
 /// __Note:__ This type implements `PartialEq` and `Hash` in a way that only considers the variant itself,
 /// not the underlying data. If full comparisons are needed, they should be done with the inner data or
 /// with a custom wrapper.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub enum EventType {
     /// An event that occurs when the user clicks a widget
     Click(CursorEvent),
@@ -129,7 +129,7 @@ pub enum EventType {
     /// An event that occurs when a widget loses focus
     Blur,
     /// An event that occurs when the user types in a character within a _focused_ widget
-    CharInput { c: char },
+    CharInput { c: smol_str::SmolStr },
     /// An event that occurs when the user releases a key within a _focused_ widget
     KeyUp(KeyboardEvent),
     /// An event that occurs when the user presses a key down within a _focused_ widget
diff --git a/src/event_dispatcher.rs b/src/event_dispatcher.rs
index e315ee1e..98d3355d 100644
--- a/src/event_dispatcher.rs
+++ b/src/event_dispatcher.rs
@@ -217,7 +217,7 @@ impl EventDispatcher {
                 };
 
                 // --- Update State --- //
-                Self::insert_event(&mut next_events, &index, node_event.event_type);
+                Self::insert_event(&mut next_events, &index, node_event.event_type.clone());
 
                 // --- Call Event --- //
                 if let Some(mut entity) = world.get_entity_mut(index.0) {
@@ -450,7 +450,7 @@ impl EventDispatcher {
             // These events are ones that require a specific target and need the tree to be evaluated before selecting the best match
             for (event_type, state) in states {
                 if let Some(node) = state.best_match {
-                    event_stream.push(KEvent::new(node.0, event_type));
+                    event_stream.push(KEvent::new(node.0, event_type.clone()));
 
                     match event_type {
                         EventType::Focus => {
@@ -692,9 +692,10 @@ impl EventDispatcher {
         let mut event_stream = Vec::new();
         if let Some(current_focus) = focus_tree.current() {
             match input_event {
-                InputEvent::CharEvent { c } => {
-                    event_stream.push(KEvent::new(current_focus, EventType::CharInput { c: *c }))
-                }
+                InputEvent::CharEvent { c } => event_stream.push(KEvent::new(
+                    current_focus,
+                    EventType::CharInput { c: c.clone() },
+                )),
                 InputEvent::Keyboard { key, is_pressed } => {
                     // === Modifers === //
                     match key {
diff --git a/src/input.rs b/src/input.rs
index 262e2258..2dccc461 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -78,16 +78,16 @@ pub(crate) fn process_events(world: &mut World) {
             }
 
             for event in custom_event_char_input.0.read(&char_input_events) {
-                input_events.push(InputEvent::CharEvent { c: event.char });
+                input_events.push(InputEvent::CharEvent {
+                    c: event.char.clone(),
+                });
             }
 
             for event in custom_event_keyboard.0.read(&keyboard_input_events) {
-                if let Some(key_code) = event.key_code {
-                    input_events.push(InputEvent::Keyboard {
-                        key: key_code,
-                        is_pressed: matches!(event.state, ButtonState::Pressed),
-                    });
-                }
+                input_events.push(InputEvent::Keyboard {
+                    key: event.key_code,
+                    is_pressed: matches!(event.state, ButtonState::Pressed),
+                });
             }
         },
         world,
diff --git a/src/input_event.rs b/src/input_event.rs
index 6bb7ec7a..7b4b3718 100644
--- a/src/input_event.rs
+++ b/src/input_event.rs
@@ -12,7 +12,7 @@ pub enum InputEvent {
     /// An event that occurs when the user scrolls
     Scroll { dx: f32, dy: f32, is_line: bool },
     /// An event that occurs when the user types in a character
-    CharEvent { c: char },
+    CharEvent { c: smol_str::SmolStr },
     /// An event that occurs when the user presses or releases a key
     Keyboard { key: KeyCode, is_pressed: bool },
 }
diff --git a/src/lib.rs b/src/lib.rs
index c98b67ef..0929cb70 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -53,8 +53,8 @@ pub mod prelude {
     pub use crate::on_change::OnChange;
     pub use crate::on_event::OnEvent;
     pub use crate::on_layout::OnLayout;
-    pub use crate::render::draw_ui_graph;
     pub use crate::render::font::FontMapping;
+    pub use crate::render::{DrawUiGraph, KayakUiPass};
     pub use crate::styles::*;
     pub use crate::tree::*;
     pub use crate::widget::*;
diff --git a/src/render/extract.rs b/src/render/extract.rs
index dc1dfeee..b0e7de47 100644
--- a/src/render/extract.rs
+++ b/src/render/extract.rs
@@ -62,7 +62,7 @@ pub fn extract(
         let dpi = if let Ok(camera) = cameras.get(context.camera_entity) {
             if let bevy::render::camera::RenderTarget::Window(WindowRef::Primary) = &camera.target {
                 if let Ok(window) = primary_window.get_single() {
-                    window.scale_factor() as f32
+                    window.scale_factor()
                 } else {
                     1.0
                 }
@@ -219,7 +219,7 @@ pub fn prepare_view_uniforms(
         let frustum = [Vec4::ZERO; 6];
 
         let view_uniforms = UIViewUniformOffset {
-            offset: view_uniforms.uniforms.push(UIViewUniform {
+            offset: view_uniforms.uniforms.push(&UIViewUniform {
                 view_proj: camera
                     .view_projection
                     .unwrap_or_else(|| projection * inverse_view),
diff --git a/src/render/material/pipeline.rs b/src/render/material/pipeline.rs
index 8b1177d8..655bf0d9 100644
--- a/src/render/material/pipeline.rs
+++ b/src/render/material/pipeline.rs
@@ -28,10 +28,12 @@ use kayak_font::bevy::FontTextureCache;
 use std::hash::Hash;
 use std::marker::PhantomData;
 
+#[cfg(feature = "svg")]
+use crate::render::svg::RenderSvgs;
+
 use crate::render::{
     extract::UIExtractedView,
     opacity_layer::OpacityLayerManager,
-    svg::RenderSvgs,
     ui_pass::{TransparentOpacityUI, TransparentUI, UIRenderPhase},
     unified::pipeline::{
         queue_quads_inner, DrawUIDraw, ExtractedQuad, ImageBindGroups, MaterialZ, PreviousClip,
@@ -167,6 +169,7 @@ pub fn extract_materials_ui<M: MaterialUI>(
                 changed_assets.remove(id);
                 removed.push(*id);
             }
+            AssetEvent::Unused { id: _ } => {}
         }
     }
 
@@ -284,17 +287,20 @@ pub type DrawMaterialUITransparent<M> = (
 pub struct SetMaterialBindGroup<M: MaterialUI, const I: usize>(PhantomData<M>);
 impl<P: PhaseItem, M: MaterialUI, const I: usize> RenderCommand<P> for SetMaterialBindGroup<M, I> {
     type Param = SRes<RenderMaterialsUI<M>>;
-    type ViewWorldQuery = ();
-    type ItemWorldQuery = Read<Handle<M>>;
+    type ViewQuery = ();
+    type ItemQuery = Read<Handle<M>>;
 
     #[inline]
     fn render<'w>(
         _item: &P,
         _view: (),
-        material2d_handle: ROQueryItem<'_, Self::ItemWorldQuery>,
+        material2d_handle: Option<ROQueryItem<'_, Self::ItemQuery>>,
         materials: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
+        let Some(material2d_handle) = material2d_handle else {
+            return RenderCommandResult::Failure;
+        };
         let asset_id: AssetId<M> = material2d_handle.clone_weak().into();
         let material2d = materials.into_inner().get(&asset_id).unwrap();
         pass.set_bind_group(I, &material2d.bind_group, &[]);
@@ -303,7 +309,7 @@ impl<P: PhaseItem, M: MaterialUI, const I: usize> RenderCommand<P> for SetMateri
 }
 
 pub fn queue_material_ui_quads<M: MaterialUI>(
-    render_svgs: Res<RenderSvgs>,
+    #[cfg(feature = "svg")] render_svgs: Res<RenderSvgs>,
     opacity_layers: Res<OpacityLayerManager>,
     mut commands: Commands,
     draw_functions: Res<DrawFunctions<TransparentUI>>,
@@ -410,6 +416,7 @@ pub fn queue_material_ui_quads<M: MaterialUI>(
                     &mut image_bind_groups,
                     &gpu_images,
                     &quad_pipeline,
+                    #[cfg(feature = "svg")]
                     &render_svgs,
                     &mut transparent_phase,
                     &mut opacity_transparent_phase,
diff --git a/src/render/mod.rs b/src/render/mod.rs
index c6d27223..90c0d0d4 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -3,7 +3,7 @@ use bevy::{
     render::{
         camera::RenderTarget,
         render_asset::RenderAssets,
-        render_graph::{RenderGraph, RunGraphOnViewNode},
+        render_graph::{RenderGraph, RenderLabel, RenderSubGraph, RunGraphOnViewNode},
         render_phase::DrawFunctions,
         Extract, ExtractSchedule, Render, RenderApp, RenderSet,
     },
@@ -28,6 +28,7 @@ pub mod material;
 pub(crate) mod nine_patch;
 mod opacity_layer;
 pub(crate) mod quad;
+#[cfg(feature = "svg")]
 pub(crate) mod svg;
 pub(crate) mod texture_atlas;
 mod ui_pass;
@@ -35,12 +36,11 @@ pub mod unified;
 
 pub use opacity_layer::MAX_OPACITY_LAYERS;
 
-pub mod draw_ui_graph {
-    pub const NAME: &str = "kayak_draw_ui";
-    pub mod node {
-        pub const MAIN_PASS: &str = "kayak_ui_pass";
-    }
-}
+#[derive(Debug, Hash, PartialEq, Eq, Clone, RenderSubGraph)]
+pub struct DrawUiGraph;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
+pub struct KayakUiPass;
 
 /// The default Kayak UI rendering plugin.
 /// Use this to render the UI.
@@ -85,43 +85,39 @@ impl Plugin for BevyKayakUIRenderPlugin {
         let ui_graph_3d = get_ui_graph(render_app);
         let mut graph = render_app.world.resource_mut::<RenderGraph>();
 
-        if let Some(graph_2d) = graph.get_sub_graph_mut(bevy::core_pipeline::core_2d::graph::NAME) {
-            graph_2d.add_sub_graph(draw_ui_graph::NAME, ui_graph_2d);
-            graph_2d.add_node(
-                draw_ui_graph::node::MAIN_PASS,
-                RunGraphOnViewNode::new(draw_ui_graph::NAME),
-            );
+        if let Some(graph_2d) = graph.get_sub_graph_mut(bevy::core_pipeline::core_2d::graph::Core2d)
+        {
+            graph_2d.add_sub_graph(DrawUiGraph, ui_graph_2d);
+            graph_2d.add_node(KayakUiPass, RunGraphOnViewNode::new(DrawUiGraph));
             graph_2d.add_node_edge(
-                bevy::core_pipeline::core_2d::graph::node::MAIN_PASS,
-                draw_ui_graph::node::MAIN_PASS,
+                bevy::core_pipeline::core_2d::graph::Node2d::MainPass,
+                KayakUiPass,
             );
             graph_2d.add_node_edge(
-                bevy::core_pipeline::core_2d::graph::node::TONEMAPPING,
-                draw_ui_graph::node::MAIN_PASS,
+                bevy::core_pipeline::core_2d::graph::Node2d::Tonemapping,
+                KayakUiPass,
             );
             graph_2d.add_node_edge(
-                draw_ui_graph::node::MAIN_PASS,
-                bevy::core_pipeline::core_2d::graph::node::UPSCALING,
+                KayakUiPass,
+                bevy::core_pipeline::core_2d::graph::Node2d::Upscaling,
             );
         }
 
-        if let Some(graph_3d) = graph.get_sub_graph_mut(bevy::core_pipeline::core_3d::graph::NAME) {
-            graph_3d.add_sub_graph(draw_ui_graph::NAME, ui_graph_3d);
-            graph_3d.add_node(
-                draw_ui_graph::node::MAIN_PASS,
-                RunGraphOnViewNode::new(draw_ui_graph::NAME),
-            );
+        if let Some(graph_3d) = graph.get_sub_graph_mut(bevy::core_pipeline::core_3d::graph::Core3d)
+        {
+            graph_3d.add_sub_graph(DrawUiGraph, ui_graph_3d);
+            graph_3d.add_node(KayakUiPass, RunGraphOnViewNode::new(DrawUiGraph));
             graph_3d.add_node_edge(
-                bevy::core_pipeline::core_3d::graph::node::END_MAIN_PASS,
-                draw_ui_graph::node::MAIN_PASS,
+                bevy::core_pipeline::core_3d::graph::Node3d::EndMainPass,
+                KayakUiPass,
             );
             graph_3d.add_node_edge(
-                bevy::core_pipeline::core_3d::graph::node::TONEMAPPING,
-                draw_ui_graph::node::MAIN_PASS,
+                bevy::core_pipeline::core_3d::graph::Node3d::Tonemapping,
+                KayakUiPass,
             );
             graph_3d.add_node_edge(
-                draw_ui_graph::node::MAIN_PASS,
-                bevy::core_pipeline::core_3d::graph::node::UPSCALING,
+                KayakUiPass,
+                bevy::core_pipeline::core_3d::graph::Node3d::Upscaling,
             );
         }
     }
@@ -130,7 +126,7 @@ impl Plugin for BevyKayakUIRenderPlugin {
 fn get_ui_graph(render_app: &mut App) -> RenderGraph {
     let ui_pass_node = MainPassUINode::new(&mut render_app.world);
     let mut ui_graph = RenderGraph::default();
-    ui_graph.add_node(draw_ui_graph::node::MAIN_PASS, ui_pass_node);
+    ui_graph.add_node(KayakUiPass, ui_pass_node);
     ui_graph
 }
 
diff --git a/src/render/svg/mod.rs b/src/render/svg/mod.rs
index 97f3c3c9..b0df765f 100644
--- a/src/render/svg/mod.rs
+++ b/src/render/svg/mod.rs
@@ -29,6 +29,7 @@ pub fn extract_svg_asset(
                 changed_assets.remove(id);
                 render_assets.remove(id);
             }
+            _ => {}
         }
     }
 
diff --git a/src/render/ui_pass.rs b/src/render/ui_pass.rs
index 5181e7d1..a75221ca 100644
--- a/src/render/ui_pass.rs
+++ b/src/render/ui_pass.rs
@@ -235,10 +235,11 @@ impl Node for MainPassUINode {
                             resolve_target: None,
                             ops: Operations {
                                 load: LoadOp::Clear(Color::rgba(0.0, 0.0, 0.0, 0.0).into()),
-                                store: true,
+                                store: bevy::render::render_resource::StoreOp::Store,
                             },
                         })],
                         depth_stencil_attachment: None,
+                        ..Default::default()
                     };
 
                     let mut tracked_pass =
@@ -260,11 +261,9 @@ impl Node for MainPassUINode {
         {
             let pass_descriptor = RenderPassDescriptor {
                 label: Some("main_transparent_pass_UI"),
-                color_attachments: &[Some(target.get_unsampled_color_attachment(Operations {
-                    load: LoadOp::Load,
-                    store: true,
-                }))],
+                color_attachments: &[Some(target.get_unsampled_color_attachment())],
                 depth_stencil_attachment: None,
+                ..Default::default()
             };
             let mut tracked_pass = render_context.begin_tracked_render_pass(pass_descriptor);
             transparent_phase.render(&mut tracked_pass, world, view_entity);
diff --git a/src/render/unified/mod.rs b/src/render/unified/mod.rs
index 72452168..a4939631 100644
--- a/src/render/unified/mod.rs
+++ b/src/render/unified/mod.rs
@@ -1,5 +1,7 @@
+#[cfg(feature = "svg")]
+use bevy::prelude::AssetApp;
 use bevy::{
-    asset::{load_internal_asset, AssetApp, Handle},
+    asset::{load_internal_asset, Handle},
     prelude::{Commands, IntoSystemConfigs, Plugin, Query, Res, ResMut, Resource, With},
     render::{
         render_phase::AddRenderCommand,
@@ -9,6 +11,7 @@ use bevy::{
     },
     window::{PrimaryWindow, Window},
 };
+#[cfg(feature = "svg")]
 use bevy_svg::prelude::Svg;
 
 use crate::{
@@ -24,7 +27,9 @@ use self::pipeline::{
     ImageBindGroups, PreviousClip, PreviousIndex, QuadTypeOffsets,
 };
 
-use super::{svg::RenderSvgs, ui_pass::TransparentOpacityUI};
+#[cfg(feature = "svg")]
+use super::svg::RenderSvgs;
+use super::ui_pass::TransparentOpacityUI;
 
 pub mod pipeline;
 pub mod text;
@@ -40,8 +45,9 @@ pub const VERTEX_OUTPUT_HANDLE: Handle<Shader> = Handle::weak_from_u128(88288962
 pub struct UnifiedRenderPlugin;
 impl Plugin for UnifiedRenderPlugin {
     fn build(&self, app: &mut bevy::prelude::App) {
-        app.init_asset::<Svg>()
-            .add_plugins(text::TextRendererPlugin);
+        #[cfg(feature = "svg")]
+        app.init_asset::<Svg>();
+        app.add_plugins(text::TextRendererPlugin);
 
         load_internal_asset!(
             app,
@@ -77,13 +83,19 @@ impl Plugin for UnifiedRenderPlugin {
             .init_resource::<QuadTypeOffsets>()
             .init_resource::<ExtractedQuads>()
             .init_resource::<ImageBindGroups>()
-            .init_resource::<QuadMeta>()
-            .init_resource::<RenderSvgs>()
+            .init_resource::<QuadMeta>();
+        #[cfg(feature = "svg")]
+        render_app.init_resource::<RenderSvgs>();
+        render_app
             .init_resource::<PreviousClip>()
             .init_resource::<PreviousIndex>()
             .add_systems(
                 ExtractSchedule,
-                (super::svg::extract_svg_asset, extract_baseline),
+                (
+                    #[cfg(feature = "svg")]
+                    super::svg::extract_svg_asset,
+                    extract_baseline,
+                ),
             )
             .add_systems(
                 Render,
@@ -110,7 +122,7 @@ pub fn extract_baseline(
     window_size: Extract<Res<WindowSize>>,
 ) {
     let dpi = if let Ok(window) = windows.get_single() {
-        window.scale_factor() as f32
+        window.scale_factor()
     } else {
         1.0
     };
diff --git a/src/render/unified/pipeline.rs b/src/render/unified/pipeline.rs
index 154608d1..840c5d34 100644
--- a/src/render/unified/pipeline.rs
+++ b/src/render/unified/pipeline.rs
@@ -1,7 +1,10 @@
 use bevy::ecs::query::ROQueryItem;
 use bevy::ecs::system::{SystemParam, SystemParamItem};
-use bevy::prelude::{Commands, Mesh, Rect, Resource, Vec3, With};
+use bevy::prelude::{Commands, Rect, Resource, With};
+#[cfg(feature = "svg")]
+use bevy::prelude::{Mesh, Vec3};
 use bevy::render::globals::{GlobalsBuffer, GlobalsUniform};
+#[cfg(feature = "svg")]
 use bevy::render::mesh::VertexAttributeValues;
 use bevy::render::render_phase::{
     DrawFunctionId, PhaseItem, RenderCommand, RenderCommandResult, SetItemPipeline,
@@ -21,20 +24,21 @@ use bevy::{
         render_asset::RenderAssets,
         render_phase::{DrawFunctions, TrackedRenderPass},
         render_resource::{
-            BindGroup, BindGroupEntry, BindGroupLayout, BindGroupLayoutDescriptor,
-            BindGroupLayoutEntry, BindingResource, BindingType, BlendState, BufferBindingType,
-            BufferSize, BufferUsages, BufferVec, ColorTargetState, ColorWrites, Extent3d,
-            FragmentState, FrontFace, MultisampleState, PipelineCache, PolygonMode, PrimitiveState,
-            PrimitiveTopology, RenderPipelineDescriptor, SamplerBindingType, SamplerDescriptor,
-            ShaderStages, TextureDescriptor, TextureDimension, TextureFormat, TextureSampleType,
-            TextureUsages, TextureViewDescriptor, TextureViewDimension, VertexAttribute,
-            VertexBufferLayout, VertexFormat, VertexState, VertexStepMode,
+            BindGroup, BindGroupEntry, BindGroupLayout, BindGroupLayoutEntry, BindingResource,
+            BindingType, BlendState, BufferBindingType, BufferSize, BufferUsages, BufferVec,
+            ColorTargetState, ColorWrites, Extent3d, FragmentState, FrontFace, MultisampleState,
+            PipelineCache, PolygonMode, PrimitiveState, PrimitiveTopology,
+            RenderPipelineDescriptor, SamplerBindingType, SamplerDescriptor, ShaderStages,
+            TextureDescriptor, TextureDimension, TextureFormat, TextureSampleType, TextureUsages,
+            TextureViewDescriptor, TextureViewDimension, VertexAttribute, VertexBufferLayout,
+            VertexFormat, VertexState, VertexStepMode,
         },
         renderer::{RenderDevice, RenderQueue},
         texture::{BevyDefault, GpuImage, Image},
     },
     utils::HashMap,
 };
+#[cfg(feature = "svg")]
 use bevy_svg::prelude::Svg;
 use bytemuck::{Pod, Zeroable};
 use kayak_font::{bevy::FontTextureCache, KayakFont};
@@ -45,6 +49,7 @@ use crate::layout::LayoutCache;
 use crate::prelude::Corner;
 use crate::render::extract::{UIExtractedView, UIViewUniform, UIViewUniformOffset, UIViewUniforms};
 use crate::render::opacity_layer::OpacityLayerManager;
+#[cfg(feature = "svg")]
 use crate::render::svg::RenderSvgs;
 use crate::render::ui_pass::{
     TransparentOpacityUI, TransparentUI, TransparentUIGeneric, UIRenderPhase,
@@ -88,8 +93,9 @@ impl FromWorld for UnifiedPipeline {
         let world = world.cell();
         let render_device = world.resource::<RenderDevice>();
 
-        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[
+        let view_layout = render_device.create_bind_group_layout(
+            "ui_view_layout",
+            &[
                 BindGroupLayoutEntry {
                     binding: 0,
                     visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
@@ -111,11 +117,11 @@ impl FromWorld for UnifiedPipeline {
                     count: None,
                 },
             ],
-            label: Some("ui_view_layout"),
-        });
+        );
 
-        let types_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[BindGroupLayoutEntry {
+        let types_layout = render_device.create_bind_group_layout(
+            "ui_types_layout",
+            &[BindGroupLayoutEntry {
                 binding: 0,
                 visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
                 ty: BindingType::Buffer {
@@ -127,11 +133,11 @@ impl FromWorld for UnifiedPipeline {
                 },
                 count: None,
             }],
-            label: Some("ui_types_layout"),
-        });
+        );
 
-        let image_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[
+        let image_layout = render_device.create_bind_group_layout(
+            "image_layout",
+            &[
                 BindGroupLayoutEntry {
                     binding: 0,
                     visibility: ShaderStages::FRAGMENT,
@@ -165,8 +171,7 @@ impl FromWorld for UnifiedPipeline {
                     count: None,
                 },
             ],
-            label: Some("image_layout"),
-        });
+        );
 
         let empty_font_texture = FontTextureCache::get_empty(&render_device);
 
@@ -377,6 +382,7 @@ pub struct ExtractedQuad {
     pub image: Option<Handle<Image>>,
     pub uv_min: Option<Vec2>,
     pub uv_max: Option<Vec2>,
+    #[cfg(feature = "svg")]
     pub svg_handle: (Option<Handle<Svg>>, Option<Color>),
     pub opacity_layer: u32,
     pub c: char,
@@ -398,6 +404,7 @@ impl Default for ExtractedQuad {
             image: Default::default(),
             uv_min: Default::default(),
             uv_max: Default::default(),
+            #[cfg(feature = "svg")]
             svg_handle: Default::default(),
             opacity_layer: 0,
             c: ' ',
@@ -743,31 +750,31 @@ pub fn queue_quad_types(
 ) {
     quad_meta.types_buffer.clear();
     // sprite_meta.types_buffer.reserve(2, &render_device);
-    let quad_type_offset = quad_meta.types_buffer.push(QuadType {
+    let quad_type_offset = quad_meta.types_buffer.push(&QuadType {
         t: 0,
         _padding_1: 0,
         _padding_2: 0,
         _padding_3: 0,
     });
-    let text_sub_pixel_type_offset = quad_meta.types_buffer.push(QuadType {
+    let text_sub_pixel_type_offset = quad_meta.types_buffer.push(&QuadType {
         t: 1,
         _padding_1: 0,
         _padding_2: 0,
         _padding_3: 0,
     });
-    let text_type_offset = quad_meta.types_buffer.push(QuadType {
+    let text_type_offset = quad_meta.types_buffer.push(&QuadType {
         t: 2,
         _padding_1: 0,
         _padding_2: 0,
         _padding_3: 0,
     });
-    let image_type_offset = quad_meta.types_buffer.push(QuadType {
+    let image_type_offset = quad_meta.types_buffer.push(&QuadType {
         t: 3,
         _padding_1: 0,
         _padding_2: 0,
         _padding_3: 0,
     });
-    let box_shadow_type_offset = quad_meta.types_buffer.push(QuadType {
+    let box_shadow_type_offset = quad_meta.types_buffer.push(&QuadType {
         t: 4,
         _padding_1: 0,
         _padding_2: 0,
@@ -811,6 +818,7 @@ pub struct PreviousIndex {
 
 #[derive(SystemParam)]
 pub struct QueueQuads<'w, 's> {
+    #[cfg(feature = "svg")]
     render_svgs: Res<'w, RenderSvgs>,
     opacity_layers: Res<'w, OpacityLayerManager>,
     commands: Commands<'w, 's>,
@@ -845,6 +853,7 @@ pub struct QueueQuads<'w, 's> {
 
 pub fn queue_quads(queue_quads: QueueQuads) {
     let QueueQuads {
+        #[cfg(feature = "svg")]
         render_svgs,
         opacity_layers,
         mut commands,
@@ -944,6 +953,7 @@ pub fn queue_quads(queue_quads: QueueQuads) {
                 &mut image_bind_groups,
                 &gpu_images,
                 &unified_pipeline,
+                #[cfg(feature = "svg")]
                 &render_svgs,
                 &mut transparent_phase,
                 &mut opacity_transparent_phase,
@@ -1023,7 +1033,7 @@ pub fn queue_quads_inner(
     image_bind_groups: &mut ImageBindGroups,
     gpu_images: &RenderAssets<Image>,
     unified_pipeline: &UnifiedPipeline,
-    render_svgs: &RenderSvgs,
+    #[cfg(feature = "svg")] render_svgs: &RenderSvgs,
     transparent_phase: &mut UIRenderPhase<TransparentUI>,
     opacity_transparent_phase: &mut UIRenderPhase<TransparentOpacityUI>,
     draw_opacity_quad: DrawFunctionId,
@@ -1279,6 +1289,7 @@ pub fn queue_quads_inner(
         return;
     }
 
+    #[cfg(feature = "svg")]
     if let (Some(svg_handle), color) = (quad.svg_handle.0.as_ref(), quad.svg_handle.1.as_ref()) {
         if let Some((svg, mesh)) = render_svgs.get(&svg_handle.id()) {
             let new_height = (svg.view_box.h as f32 / svg.view_box.w as f32) * sprite_rect.size().x;
@@ -1332,79 +1343,80 @@ pub fn queue_quads_inner(
             *index += indices.len() as u32;
             *item_end = *index;
         }
-    } else {
-        let color = quad.color.as_linear_rgba_f32();
+        return;
+    }
 
-        let uv_min = quad.uv_min.unwrap_or(Vec2::ZERO);
-        let uv_max = quad.uv_max.unwrap_or(Vec2::ONE);
+    let color = quad.color.as_linear_rgba_f32();
 
-        let bottom_left = Vec4::new(
-            uv_min.x,
-            uv_min.y,
-            quad.char_id as f32,
-            quad.border_radius.bottom_left,
-        );
-        let top_left = Vec4::new(
-            uv_min.x,
-            uv_max.y,
-            quad.char_id as f32,
-            quad.border_radius.top_left,
-        );
-        let top_right = Vec4::new(
-            uv_max.x,
-            uv_max.y,
-            quad.char_id as f32,
-            quad.border_radius.top_right,
-        );
-        let bottom_right = Vec4::new(
-            uv_max.x,
-            uv_min.y,
-            quad.char_id as f32,
-            quad.border_radius.bottom_right,
-        );
+    let uv_min = quad.uv_min.unwrap_or(Vec2::ZERO);
+    let uv_max = quad.uv_max.unwrap_or(Vec2::ONE);
 
-        let uvs: [[f32; 4]; 6] = [
-            top_left.into(),
-            bottom_right.into(),
-            bottom_left.into(),
-            top_left.into(),
-            top_right.into(),
-            bottom_right.into(),
-        ];
-
-        const QUAD_INDICES: [usize; 6] = [0, 2, 3, 0, 1, 2];
-
-        const QUAD_VERTEX_POSITIONS: [Vec2; 4] = [
-            Vec2::new(0.0, 0.0),
-            Vec2::new(1.0, 0.0),
-            Vec2::new(1.0, 1.0),
-            Vec2::new(0.0, 1.0),
-        ];
-
-        for (index, vertex_index) in QUAD_INDICES.iter().enumerate() {
-            let vertex_position = QUAD_VERTEX_POSITIONS[*vertex_index];
-            let world = Mat4::from_scale_rotation_translation(
-                sprite_rect.size().extend(1.0),
-                Quat::default(),
-                sprite_rect.min.extend(0.0),
-            );
-            let final_position = (world * vertex_position.extend(0.0).extend(1.0)).truncate();
-            quad_meta.vertices.push(QuadVertex {
-                position: final_position.into(),
-                color,
-                uv: uvs[index],
-                pos_size: [
-                    sprite_rect.min.x,
-                    sprite_rect.min.y,
-                    sprite_rect.size().x,
-                    sprite_rect.size().y,
-                ],
-            });
-        }
+    let bottom_left = Vec4::new(
+        uv_min.x,
+        uv_min.y,
+        quad.char_id as f32,
+        quad.border_radius.bottom_left,
+    );
+    let top_left = Vec4::new(
+        uv_min.x,
+        uv_max.y,
+        quad.char_id as f32,
+        quad.border_radius.top_left,
+    );
+    let top_right = Vec4::new(
+        uv_max.x,
+        uv_max.y,
+        quad.char_id as f32,
+        quad.border_radius.top_right,
+    );
+    let bottom_right = Vec4::new(
+        uv_max.x,
+        uv_min.y,
+        quad.char_id as f32,
+        quad.border_radius.bottom_right,
+    );
 
-        *index += QUAD_INDICES.len() as u32;
-        *item_end = *index;
+    let uvs: [[f32; 4]; 6] = [
+        top_left.into(),
+        bottom_right.into(),
+        bottom_left.into(),
+        top_left.into(),
+        top_right.into(),
+        bottom_right.into(),
+    ];
+
+    const QUAD_INDICES: [usize; 6] = [0, 2, 3, 0, 1, 2];
+
+    const QUAD_VERTEX_POSITIONS: [Vec2; 4] = [
+        Vec2::new(0.0, 0.0),
+        Vec2::new(1.0, 0.0),
+        Vec2::new(1.0, 1.0),
+        Vec2::new(0.0, 1.0),
+    ];
+
+    for (index, vertex_index) in QUAD_INDICES.iter().enumerate() {
+        let vertex_position = QUAD_VERTEX_POSITIONS[*vertex_index];
+        let world = Mat4::from_scale_rotation_translation(
+            sprite_rect.size().extend(1.0),
+            Quat::default(),
+            sprite_rect.min.extend(0.0),
+        );
+        let final_position = (world * vertex_position.extend(0.0).extend(1.0)).truncate();
+        quad_meta.vertices.push(QuadVertex {
+            position: final_position.into(),
+            color,
+            uv: uvs[index],
+            pos_size: [
+                sprite_rect.min.x,
+                sprite_rect.min.y,
+                sprite_rect.size().x,
+                sprite_rect.size().y,
+            ],
+        });
     }
+
+    *index += QUAD_INDICES.len() as u32;
+    *item_end = *index;
 }
 
 pub type DrawUI = (
@@ -1424,14 +1436,14 @@ pub struct SetUIViewBindGroup<T, const I: usize> {
 }
 impl<T: PhaseItem, const I: usize> RenderCommand<T> for SetUIViewBindGroup<T, I> {
     type Param = ();
-    type ViewWorldQuery = (Read<UIViewUniformOffset>, Read<UIViewBindGroup>);
-    type ItemWorldQuery = ();
+    type ViewQuery = (Read<UIViewUniformOffset>, Read<UIViewBindGroup>);
+    type ItemQuery = ();
 
     #[inline]
     fn render<'w>(
         _item: &T,
-        (view_uniform, ui_view_bind_group): ROQueryItem<'w, Self::ViewWorldQuery>,
-        _: (),
+        (view_uniform, ui_view_bind_group): ROQueryItem<'w, Self::ViewQuery>,
+        _: Option<()>,
         _: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
@@ -1448,16 +1460,19 @@ pub struct DrawUIDraw<T> {
 impl<T: PhaseItem + TransparentUIGeneric> RenderCommand<T> for DrawUIDraw<T> {
     type Param = (SRes<QuadMeta>, SRes<UnifiedPipeline>, SRes<ImageBindGroups>);
 
-    type ViewWorldQuery = Read<UIExtractedView>;
-    type ItemWorldQuery = Read<QuadBatch>;
+    type ViewQuery = Read<UIExtractedView>;
+    type ItemQuery = Read<QuadBatch>;
 
     fn render<'w>(
         item: &T,
-        view: bevy::ecs::query::ROQueryItem<'w, Self::ViewWorldQuery>,
-        batch: bevy::ecs::query::ROQueryItem<'w, Self::ItemWorldQuery>,
+        view: bevy::ecs::query::ROQueryItem<'w, Self::ViewQuery>,
+        batch: Option<bevy::ecs::query::ROQueryItem<'w, Self::ItemQuery>>,
         param: bevy::ecs::system::SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
+        let Some(batch) = batch else {
+            return RenderCommandResult::Failure;
+        };
         let (quad_meta, unified_pipeline, image_bind_groups) = param;
 
         let quad_meta = quad_meta.into_inner();
diff --git a/src/render_primitive.rs b/src/render_primitive.rs
index 26b2ba80..6b58dcff 100644
--- a/src/render_primitive.rs
+++ b/src/render_primitive.rs
@@ -1,12 +1,14 @@
 use bevy::prelude::*;
 use kayak_font::KayakFont;
 
+#[cfg(feature = "svg")]
+use crate::styles::StyleProp;
 use crate::{
     render::{
         font::FontMapping,
         unified::pipeline::{ExtractedQuad, ExtractedQuads, QuadOrMaterial, UIQuadType},
     },
-    styles::{Corner, KStyle, RenderCommand, StyleProp},
+    styles::{Corner, KStyle, RenderCommand},
 };
 
 pub trait RenderPrimitive {
@@ -250,6 +252,7 @@ impl RenderPrimitive for KStyle {
                     );
                 }
             }
+            #[cfg(feature = "svg")]
             RenderCommand::Svg { handle } => {
                 let mut svgs = crate::render::svg::extract_svg(
                     camera_entity,
diff --git a/src/styles/render_command.rs b/src/styles/render_command.rs
index cfe3dda3..27453ed8 100644
--- a/src/styles/render_command.rs
+++ b/src/styles/render_command.rs
@@ -2,6 +2,7 @@ use bevy::{
     prelude::{Handle, Image, Vec2},
     reflect::Reflect,
 };
+#[cfg(feature = "svg")]
 use bevy_svg::prelude::Svg;
 use kayak_font::{Alignment, TextLayout, TextProperties};
 
@@ -34,6 +35,7 @@ pub enum RenderCommand {
         border: Edge<f32>,
         handle: Handle<Image>,
     },
+    #[cfg(feature = "svg")]
     Svg {
         handle: Handle<Svg>,
     },
diff --git a/src/styles/style.rs b/src/styles/style.rs
index 25538b26..0fa75dc9 100644
--- a/src/styles/style.rs
+++ b/src/styles/style.rs
@@ -781,7 +781,7 @@ fn hsv_to_rgb(from: &Vec3) -> Color {
 
     res += Vec4::new(m, m, m, 0.0);
 
-    Color::from(res)
+    Color::rgba_from_array(res)
 }
 
 fn hsv_lerp(from: &Color, to: &Color, amount: f32) -> Color {
diff --git a/src/widgets/accordion/summary.rs b/src/widgets/accordion/summary.rs
index 70228cb9..37b6a006 100644
--- a/src/widgets/accordion/summary.rs
+++ b/src/widgets/accordion/summary.rs
@@ -61,7 +61,7 @@ pub fn render(
             .with_style(styles)
             .with_style(KStyle {
                 render_command: RenderCommand::Layout.into(),
-                cursor: KCursorIcon(CursorIcon::Hand).into(),
+                cursor: KCursorIcon(CursorIcon::Pointer).into(),
                 width: Units::Stretch(1.0).into(),
                 height: Units::Auto.into(),
                 ..Default::default()
@@ -97,7 +97,7 @@ pub fn render(
                             height: Units::Auto.into(),
                             padding: Edge::new(Units::Pixels(12.0), Units::Pixels(16.0), Units::Pixels(16.0), Units::Pixels(16.0)).into(),
                             layout_type: LayoutType::Row.into(),
-                            cursor: KCursorIcon(CursorIcon::Hand).into(),
+                            cursor: KCursorIcon(CursorIcon::Pointer).into(),
                             ..Default::default()
                         }}
                         on_event={on_event}
@@ -107,7 +107,7 @@ pub fn render(
                             styles={KStyle {
                                 width: Units::Pixels(25.0).into(),
                                 height: Units::Pixels(20.0).into(),
-                                cursor: KCursorIcon(CursorIcon::Hand).into(),
+                                cursor: KCursorIcon(CursorIcon::Pointer).into(),
                                 ..Default::default()
                             }}
                         >
@@ -117,7 +117,7 @@ pub fn render(
                                         <KSvgBundle
                                             styles={KStyle {
                                                 background_color: Color::WHITE.into(),
-                                                cursor: KCursorIcon(CursorIcon::Hand).into(),
+                                                cursor: KCursorIcon(CursorIcon::Pointer).into(),
                                                 width: Units::Pixels(35.0).into(),
                                                 height: Units::Pixels(30.0).into(),
                                                 top: Units::Pixels(-10.0).into(),
@@ -131,7 +131,7 @@ pub fn render(
                                         <KSvgBundle
                                             styles={KStyle {
                                                 background_color: Color::WHITE.into(),
-                                                cursor: KCursorIcon(CursorIcon::Hand).into(),
+                                                cursor: KCursorIcon(CursorIcon::Pointer).into(),
                                                 width: Units::Pixels(35.0).into(),
                                                 height: Units::Pixels(30.0).into(),
                                                 top: Units::Pixels(-10.0).into(),
diff --git a/src/widgets/button.rs b/src/widgets/button.rs
index 65ca9808..a804bf3d 100644
--- a/src/widgets/button.rs
+++ b/src/widgets/button.rs
@@ -83,7 +83,7 @@ pub fn button_render(
                     font_size: StyleProp::Value(font_size),
                     height: StyleProp::Value(height),
                     width: Units::Stretch(1.0).into(),
-                    cursor: StyleProp::Value(KCursorIcon(CursorIcon::Hand)),
+                    cursor: StyleProp::Value(KCursorIcon(CursorIcon::Pointer)),
                     ..Default::default()
                 })
                 .into();
diff --git a/src/widgets/mod.rs b/src/widgets/mod.rs
index 2f715d98..2ee1a494 100644
--- a/src/widgets/mod.rs
+++ b/src/widgets/mod.rs
@@ -22,17 +22,20 @@
 
 use bevy::prelude::*;
 
+#[cfg(feature = "svg")]
 mod accordion;
 mod app;
 mod background;
 mod button;
 mod clip;
 mod element;
+#[cfg(feature = "svg")]
 mod icons;
 mod image;
 mod modal;
 mod nine_patch;
 mod scroll;
+#[cfg(feature = "svg")]
 mod svg;
 mod text;
 mod text_box;
@@ -41,12 +44,14 @@ mod transition;
 mod window;
 mod window_context_provider;
 
+#[cfg(feature = "svg")]
 pub use accordion::*;
 pub use app::{KayakApp, KayakAppBundle};
 pub use background::{Background, BackgroundBundle};
 pub use button::{ButtonState, KButton, KButtonBundle};
 pub use clip::{Clip, ClipBundle};
 pub use element::{Element, ElementBundle};
+#[cfg(feature = "svg")]
 pub use icons::*;
 pub use image::{KImage, KImageBundle};
 pub use modal::{Modal, ModalBundle};
@@ -59,6 +64,7 @@ pub use scroll::{
         ScrollContext, ScrollContextProvider, ScrollContextProviderBundle, ScrollMode,
     },
 };
+#[cfg(feature = "svg")]
 pub use svg::{KSvg, KSvgBundle, Svg};
 pub use text::{TextProps, TextWidgetBundle};
 pub use text_box::{TextBoxBundle, TextBoxProps, TextBoxState};
@@ -83,6 +89,7 @@ use scroll::{
     scroll_bar::scroll_bar_render, scroll_box::scroll_box_render,
     scroll_content::scroll_content_render, scroll_context::scroll_context_render,
 };
+#[cfg(feature = "svg")]
 use svg::svg_render;
 use text::text_render;
 use text_box::text_box_render;
@@ -101,6 +108,7 @@ pub struct KayakWidgets;
 
 impl Plugin for KayakWidgets {
     fn build(&self, app: &mut bevy::prelude::App) {
+        #[cfg(feature = "svg")]
         app.add_plugins(icons::IconsPlugin);
         app.add_systems(
             PostUpdate,
@@ -114,6 +122,7 @@ pub struct KayakWidgetsContextPlugin;
 
 impl KayakUIPlugin for KayakWidgetsContextPlugin {
     fn build(&self, context: &mut KayakRootContext) {
+        #[cfg(feature = "svg")]
         context.add_plugin(AccordionPlugin);
         context.add_widget_data::<KayakApp, EmptyState>();
         context.add_widget_data::<KButton, ButtonState>();
@@ -125,6 +134,7 @@ impl KayakUIPlugin for KayakWidgetsContextPlugin {
         context.add_widget_data::<KImage, EmptyState>();
         context.add_widget_data::<TextureAtlasProps, EmptyState>();
         context.add_widget_data::<NinePatch, EmptyState>();
+        #[cfg(feature = "svg")]
         context.add_widget_data::<KSvg, EmptyState>();
         context.add_widget_data::<Element, EmptyState>();
         context.add_widget_data::<ScrollBarProps, EmptyState>();
@@ -181,6 +191,7 @@ impl KayakUIPlugin for KayakWidgetsContextPlugin {
             widget_update::<NinePatch, EmptyState>,
             nine_patch_render,
         );
+        #[cfg(feature = "svg")]
         context.add_widget_system(
             KSvg::default().get_name(),
             widget_update::<KSvg, EmptyState>,
diff --git a/src/widgets/modal.rs b/src/widgets/modal.rs
index 4da4988d..96973893 100644
--- a/src/widgets/modal.rs
+++ b/src/widgets/modal.rs
@@ -154,7 +154,7 @@ pub fn render(
                     >
                         <BackgroundBundle
                             styles={KStyle {
-                                cursor: KCursorIcon(CursorIcon::Hand).into(),
+                                cursor: KCursorIcon(CursorIcon::Pointer).into(),
                                 render_command: RenderCommand::Quad.into(),
                                 background_color: Color::rgba(0.188, 0.203, 0.274, 1.0).into(),
                                 border_radius:  Corner::all(10.0).into(),
diff --git a/src/widgets/text_box.rs b/src/widgets/text_box.rs
index e7512d6a..be0b4db8 100644
--- a/src/widgets/text_box.rs
+++ b/src/widgets/text_box.rs
@@ -188,7 +188,7 @@ pub fn text_box_render(
                       mut state_query: Query<&mut TextBoxState>| {
                     match event.event_type {
                         EventType::KeyDown(key_event) => {
-                            if key_event.key() == KeyCode::Right {
+                            if key_event.key() == KeyCode::ArrowRight {
                                 if let Ok(mut state) = state_query.get_mut(state_entity) {
                                     if state.cursor_position < state.graphemes.len() {
                                         state.cursor_position += 1;
@@ -201,7 +201,7 @@ pub fn text_box_render(
                                     );
                                 }
                             }
-                            if key_event.key() == KeyCode::Left {
+                            if key_event.key() == KeyCode::ArrowLeft {
                                 if let Ok(mut state) = state_query.get_mut(state_entity) {
                                     if state.cursor_position > 0 {
                                         state.cursor_position -= 1;
@@ -215,30 +215,33 @@ pub fn text_box_render(
                                 }
                             }
                         }
-                        EventType::CharInput { c } => {
+                        EventType::CharInput { ref c } => {
                             if let Ok(mut state) = state_query.get_mut(state_entity) {
                                 let cloned_on_change = cloned_on_change.clone();
                                 if !state.focused {
                                     return;
                                 }
                                 let cursor_pos = state.cursor_position;
-                                if is_backspace(c) {
-                                    if !state.current_value.is_empty() {
-                                        let char_pos: usize = state.graphemes[0..cursor_pos - 1]
+                                for c in c.chars() {
+                                    if is_backspace(c) {
+                                        if !state.current_value.is_empty() {
+                                            let char_pos: usize = state.graphemes
+                                                [0..cursor_pos - 1]
+                                                .iter()
+                                                .map(|g| g.len())
+                                                .sum();
+                                            state.current_value.remove(char_pos);
+                                            state.cursor_position -= 1;
+                                        }
+                                    } else if !c.is_control() {
+                                        let char_pos: usize = state.graphemes[0..cursor_pos]
                                             .iter()
                                             .map(|g| g.len())
                                             .sum();
-                                        state.current_value.remove(char_pos);
-                                        state.cursor_position -= 1;
+                                        state.current_value.insert(char_pos, c);
+
+                                        state.cursor_position += 1;
                                     }
-                                } else if !c.is_control() {
-                                    let char_pos: usize = state.graphemes[0..cursor_pos]
-                                        .iter()
-                                        .map(|g| g.len())
-                                        .sum();
-                                    state.current_value.insert(char_pos, c);
-
-                                    state.cursor_position += 1;
                                 }
 
                                 // Update graphemes
diff --git a/src/widgets/window.rs b/src/widgets/window.rs
index d6aa262b..731762a3 100644
--- a/src/widgets/window.rs
+++ b/src/widgets/window.rs
@@ -188,7 +188,7 @@ pub fn window_render(
                     <BackgroundBundle
                         id={"title_bar_entity"}
                         styles={KStyle {
-                            cursor: StyleProp::Value(KCursorIcon(CursorIcon::Hand)),
+                            cursor: StyleProp::Value(KCursorIcon(CursorIcon::Pointer)),
                             render_command: StyleProp::Value(RenderCommand::Quad),
                             background_color: StyleProp::Value(Color::rgba(0.188, 0.203, 0.274, 1.0)),
                             border_radius: Corner::all(10.0).into(),