diff --git a/.gitignore b/.gitignore
index eb1d4ef..3642657 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 /target
 Cargo.lock
-.vscode
\ No newline at end of file
+.vscode
+
+.idea/
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index e8fa50b..c7259e0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "bevy_polyline"
-version = "0.7.0"
+version = "0.8.0"
 description = "Polyline Rendering for Bevy"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/ForesightMiningSoftwareCorporation/bevy_polyline"
@@ -17,8 +17,8 @@ authors = [
 ]
 
 [dependencies]
-bitflags = "2.3"
-bevy = { version = "0.11.0", default-features = false, features = [
+bitflags = "2.4.1"
+bevy = { version = "0.12.0", default-features = false, features = [
     "bevy_core_pipeline",
     "bevy_render",
     "bevy_asset",
@@ -26,13 +26,13 @@ bevy = { version = "0.11.0", default-features = false, features = [
 
 [dependencies.naga]
 features = ["glsl-in", "spv-out", "wgsl-out"]
-version = "0.12"
+version = "0.14"
 
 [dev-dependencies]
 lazy_static = "1.4.0"
 rand = "0.8.4"
-ringbuffer = "0.14"
-bevy = { version = "0.11.0", default-features = false, features = [
+ringbuffer = "0.15"
+bevy = { version = "0.12", default-features = false, features = [
     "bevy_winit",
     "bevy_pbr",
     "x11",
diff --git a/README.md b/README.md
index 251d9d7..1303324 100644
--- a/README.md
+++ b/README.md
@@ -46,7 +46,8 @@ Due to instancing, Bevy Polyline only makes one drawcall per `PolyLine`, one for
 We intend to track the `main` branch of Bevy. PRs supporting this are welcome!
 
 | bevy | bevy_polyline |
-| ---- | ------------- |
+|------|---------------|
+| 0.12 | 0.8           |
 | 0.11 | 0.7           |
 | 0.10 | 0.5, 0.6      |
 | 0.9  | 0.4           |
diff --git a/examples/depth_bias.rs b/examples/depth_bias.rs
index 78a59a6..8f2ad1a 100644
--- a/examples/depth_bias.rs
+++ b/examples/depth_bias.rs
@@ -1,5 +1,6 @@
 use std::f32::consts::TAU;
 use std::f64::consts::TAU as TAU64;
+use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 
 use bevy::prelude::*;
 use bevy_polyline::prelude::*;
@@ -23,6 +24,8 @@ fn main() {
         .insert_resource(ClearColor(Color::BLACK))
         .insert_resource(Msaa::Sample4)
         .add_plugins(DefaultPlugins)
+        .add_plugins(FrameTimeDiagnosticsPlugin::default())
+        .add_plugins(LogDiagnosticsPlugin::default())
         .add_plugins(PolylinePlugin)
         .add_systems(Update, (move_camera, rotate_plane))
         .add_systems(Startup, setup)
diff --git a/examples/linestrip.rs b/examples/linestrip.rs
index 27c8cd2..8fd56d9 100644
--- a/examples/linestrip.rs
+++ b/examples/linestrip.rs
@@ -1,10 +1,13 @@
 use bevy::{pbr::PointLightBundle, prelude::*};
+use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy_polyline::prelude::*;
 
 fn main() {
     App::new()
         .insert_resource(Msaa::Sample4)
         .add_plugins(DefaultPlugins)
+        .add_plugins(FrameTimeDiagnosticsPlugin::default())
+        .add_plugins(LogDiagnosticsPlugin::default())
         .add_plugins(PolylinePlugin)
         .add_systems(Startup, setup)
         .add_systems(Update, rotator_system)
diff --git a/examples/minimal.rs b/examples/minimal.rs
index eb4c004..de2bb85 100644
--- a/examples/minimal.rs
+++ b/examples/minimal.rs
@@ -1,9 +1,12 @@
+use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::prelude::*;
 use bevy_polyline::prelude::*;
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
+        .add_plugins(FrameTimeDiagnosticsPlugin::default())
+        .add_plugins(LogDiagnosticsPlugin::default())
         .add_plugins(PolylinePlugin)
         .add_systems(Startup, setup)
         .run();
diff --git a/examples/nbody.rs b/examples/nbody.rs
index 590f748..6497362 100644
--- a/examples/nbody.rs
+++ b/examples/nbody.rs
@@ -9,7 +9,7 @@ use bevy_polyline::prelude::*;
 
 use lazy_static::*;
 use rand::{prelude::*, Rng};
-use ringbuffer::{ConstGenericRingBuffer, RingBufferExt, RingBufferWrite};
+use ringbuffer::{ConstGenericRingBuffer, RingBuffer};
 
 const NUM_BODIES: usize = 512;
 const TRAIL_LENGTH: usize = 1024;
@@ -24,14 +24,14 @@ fn main() {
             ..Default::default()
         })
         .add_plugins(DefaultPlugins)
+        .add_plugins(FrameTimeDiagnosticsPlugin::default())
+        .add_plugins(LogDiagnosticsPlugin::default())
         .add_plugins(PolylinePlugin)
         .add_systems(Startup, setup)
         .add_systems(
             Update,
             ((nbody_system, update_trails).chain(), rotator_system),
         )
-        .add_plugins(FrameTimeDiagnosticsPlugin::default())
-        .add_plugins(LogDiagnosticsPlugin::default())
         .run();
 }
 
@@ -101,7 +101,7 @@ fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates
             (t * 0.1).sin() * 2000.0,
             r * f32::sin(t * 0.1),
         )
-        .looking_at(Vec3::ZERO, Vec3::Y);
+            .looking_at(Vec3::ZERO, Vec3::Y);
     }
 }
 
@@ -147,6 +147,7 @@ impl Simulation {
         None
     }
 }
+
 #[derive(Component, Clone, Default, Debug)]
 struct Trail(ConstGenericRingBuffer<Vec3A, TRAIL_LENGTH>);
 
@@ -208,7 +209,7 @@ fn update_trails(
     query.for_each_mut(|(body, mut trail, polyline)| {
         if let Some(position) = trail.0.back() {
             let last_vec = *position - body.position;
-            let last_last_vec = if let Some(position) = trail.0.get(-2) {
+            let last_last_vec = if let Some(position) = trail.0.get_signed(-2) {
                 *position - body.position
             } else {
                 last_vec
@@ -221,7 +222,7 @@ fn update_trails(
             } else {
                 // If the last point didn't actually add much of a curve, just overwrite it.
                 if polylines.get_mut(polyline).unwrap().vertices.len() > 1 {
-                    *trail.0.get_mut(-1).unwrap() = body.position;
+                    *trail.0.get_mut_signed(-1).unwrap() = body.position;
                     *polylines
                         .get_mut(polyline)
                         .unwrap()
diff --git a/examples/perspective.rs b/examples/perspective.rs
index 0cb1b8d..eb924fa 100644
--- a/examples/perspective.rs
+++ b/examples/perspective.rs
@@ -1,9 +1,12 @@
+use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::prelude::*;
 use bevy_polyline::prelude::*;
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
+        .add_plugins(FrameTimeDiagnosticsPlugin::default())
+        .add_plugins(LogDiagnosticsPlugin::default())
         .add_plugins(PolylinePlugin)
         .add_systems(Startup, setup)
         .add_systems(Update, (move_camera, toggle_perspective))
diff --git a/src/lib.rs b/src/lib.rs
index c79b66e..f841958 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,9 +1,9 @@
 #![allow(clippy::type_complexity)]
 #![allow(clippy::too_many_arguments)]
 
-use bevy::{prelude::*, reflect::TypeUuid};
+use bevy::prelude::*;
 use material::PolylineMaterialPlugin;
-use polyline::{PolylineBasePlugin, PolylineRenderPlugin};
+use polyline::{PolylineRenderPlugin};
 
 pub mod material;
 pub mod polyline;
@@ -14,20 +14,14 @@ pub mod prelude {
     pub use crate::PolylinePlugin;
 }
 
-pub const SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 12823766040132746065);
+pub const SHADER_HANDLE: Handle<Shader> =
+    Handle::weak_from_u128(12823766040132746065);
 
 pub struct PolylinePlugin;
 
 impl Plugin for PolylinePlugin {
-    fn build(&self, app: &mut bevy::prelude::App) {
-        let mut shaders = app.world.get_resource_mut::<Assets<Shader>>().unwrap();
-        shaders.set_untracked(
-            SHADER_HANDLE,
-            Shader::from_wgsl(include_str!("shaders/polyline.wgsl"), file!()),
-        );
+    fn build(&self, app: &mut App) {
         app.add_plugins((
-            PolylineBasePlugin,
             PolylineRenderPlugin,
             PolylineMaterialPlugin,
         ));
diff --git a/src/material.rs b/src/material.rs
index ed9eab2..50866b3 100644
--- a/src/material.rs
+++ b/src/material.rs
@@ -15,7 +15,7 @@ use bevy::{
         },
     },
     prelude::*,
-    reflect::{TypePath, TypeUuid},
+    reflect::{TypePath},
     render::{
         extract_component::ExtractComponentPlugin,
         render_asset::{RenderAsset, RenderAssetPlugin, RenderAssets},
@@ -28,8 +28,7 @@ use bevy::{
 };
 use std::fmt::Debug;
 
-#[derive(Component, Debug, PartialEq, Clone, Copy, TypeUuid, TypePath)]
-#[uuid = "69b87497-2ba0-4c38-ba82-f54bf1ffe873"]
+#[derive(Asset, Debug, PartialEq, Clone, Copy, TypePath)]
 pub struct PolylineMaterial {
     /// Width of the line.
     ///
@@ -74,11 +73,11 @@ impl Default for PolylineMaterial {
 
 impl PolylineMaterial {
     fn fragment_shader() -> Handle<Shader> {
-        SHADER_HANDLE.typed()
+        SHADER_HANDLE
     }
 
     fn vertex_shader() -> Handle<Shader> {
-        SHADER_HANDLE.typed()
+        SHADER_HANDLE
     }
 
     pub fn bind_group_layout(render_device: &RenderDevice) -> BindGroupLayout {
@@ -138,7 +137,7 @@ impl RenderAsset for PolylineMaterial {
 
     fn prepare_asset(
         material: Self::ExtractedAsset,
-        (device, queue, polyline_pipeline): &mut bevy::ecs::system::SystemParamItem<Self::Param>,
+        (device, queue, polyline_pipeline): &mut SystemParamItem<Self::Param>,
     ) -> Result<
         Self::PreparedAsset,
         bevy::render::render_asset::PrepareAssetError<Self::ExtractedAsset>,
@@ -152,27 +151,28 @@ impl RenderAsset for PolylineMaterial {
         let mut buffer = UniformBuffer::from(value);
         buffer.write_buffer(device, queue);
 
-        let bind_group = device.create_bind_group(&BindGroupDescriptor {
-            entries: &[BindGroupEntry {
-                binding: 0,
-                resource: buffer.binding().unwrap(),
-            }],
-            label: Some("polyline_material_bind_group"),
-            layout: &polyline_pipeline.material_layout,
-        });
-
-        let alpha_mode = if material.color.a() < 1.0 {
-            AlphaMode::Blend
+        if let Some(binding) = buffer.binding() {
+            let bind_group = device.create_bind_group(
+                "polyline_material_bind_group",
+                &polyline_pipeline.material_layout,
+                &BindGroupEntries::single(binding),
+            );
+
+            let alpha_mode = if material.color.a() < 1.0 {
+                AlphaMode::Blend
+            } else {
+                AlphaMode::Opaque
+            };
+
+            Ok(GpuPolylineMaterial {
+                buffer,
+                perspective: material.perspective,
+                alpha_mode,
+                bind_group,
+            })
         } else {
-            AlphaMode::Opaque
-        };
-
-        Ok(GpuPolylineMaterial {
-            buffer,
-            perspective: material.perspective,
-            alpha_mode,
-            bind_group,
-        })
+            panic!();
+        }
     }
 }
 
@@ -182,7 +182,7 @@ pub struct PolylineMaterialPlugin;
 
 impl Plugin for PolylineMaterialPlugin {
     fn build(&self, app: &mut App) {
-        app.add_asset::<PolylineMaterial>()
+        app.init_asset::<PolylineMaterial>()
             .add_plugins(ExtractComponentPlugin::<Handle<PolylineMaterial>>::default())
             .add_plugins(RenderAssetPlugin::<PolylineMaterial>::default());
     }
@@ -250,10 +250,11 @@ type DrawMaterial = (
 );
 
 pub struct SetPolylineViewBindGroup<const I: usize>;
+
 impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetPolylineViewBindGroup<I> {
+    type Param = ();
     type ViewWorldQuery = (Read<ViewUniformOffset>, Read<PolylineViewBindGroup>);
     type ItemWorldQuery = ();
-    type Param = ();
 
     #[inline]
     fn render<'w>(
@@ -269,10 +270,11 @@ impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetPolylineViewBindGroup
 }
 
 pub struct SetMaterialBindGroup<const I: usize>;
+
 impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetMaterialBindGroup<I> {
+    type Param = SRes<RenderAssets<PolylineMaterial>>;
     type ViewWorldQuery = ();
     type ItemWorldQuery = Read<Handle<PolylineMaterial>>;
-    type Param = SRes<RenderAssets<PolylineMaterial>>;
 
     fn render<'w>(
         _item: &P,
@@ -311,7 +313,7 @@ pub fn queue_material_polylines(
     )>,
 ) {
     for (view, visible_entities, mut opaque_phase, mut alpha_mask_phase, mut transparent_phase) in
-        views.iter_mut()
+    views.iter_mut()
     {
         let draw_opaque = opaque_draw_functions
             .read()
@@ -358,6 +360,8 @@ pub fn queue_material_polylines(
                                 // -z in front of the camera, values in view space decrease away from the
                                 // camera. Flipping the sign of mesh_z results in the correct front-to-back ordering
                                 distance: -polyline_z,
+                                batch_range: 0..1,
+                                dynamic_offset: None,
                             });
                         }
                         AlphaMode::Mask(_) => {
@@ -370,6 +374,8 @@ pub fn queue_material_polylines(
                                 // -z in front of the camera, values in view space decrease away from the
                                 // camera. Flipping the sign of mesh_z results in the correct front-to-back ordering
                                 distance: -polyline_z,
+                                batch_range: 0..1,
+                                dynamic_offset: None,
                             });
                         }
                         AlphaMode::Blend
@@ -385,6 +391,8 @@ pub fn queue_material_polylines(
                                 // -z in front of the camera, the largest distance is -far with values increasing toward the
                                 // camera. As such we can just use mesh_z as the distance
                                 distance: polyline_z,
+                                batch_range: 0..1,
+                                dynamic_offset: None,
                             });
                         }
                     }
diff --git a/src/polyline.rs b/src/polyline.rs
index add93fe..8158264 100644
--- a/src/polyline.rs
+++ b/src/polyline.rs
@@ -9,7 +9,7 @@ use bevy::{
         },
     },
     prelude::*,
-    reflect::{TypePath, TypeUuid},
+    reflect::{TypePath},
     render::{
         extract_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
         render_asset::{RenderAsset, RenderAssetPlugin, RenderAssets},
@@ -21,34 +21,41 @@ use bevy::{
         Extract, Render, RenderApp, RenderSet,
     },
 };
+use bevy::asset::{load_internal_asset, UntypedAssetId, VisitAssetDependencies};
 
-pub struct PolylineBasePlugin;
+pub struct PolylineRenderPlugin;
 
-impl Plugin for PolylineBasePlugin {
+impl Plugin for PolylineRenderPlugin {
     fn build(&self, app: &mut App) {
-        app.add_asset::<Polyline>()
+        load_internal_asset!(app, SHADER_HANDLE, "shaders/polyline.wgsl", Shader::from_wgsl);
+
+        app
+            .add_plugins(UniformComponentPlugin::<PolylineUniform>::default())
+            .init_asset::<Polyline>()
             .add_plugins(RenderAssetPlugin::<Polyline>::default());
-    }
-}
 
-pub struct PolylineRenderPlugin;
-impl Plugin for PolylineRenderPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_plugins(UniformComponentPlugin::<PolylineUniform>::default());
-    }
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
 
-    fn finish(&self, app: &mut App) {
-        app.sub_app_mut(RenderApp)
-            .init_resource::<PolylinePipeline>()
+        render_app
             .add_systems(ExtractSchedule, extract_polylines)
             .add_systems(
                 Render,
                 (
-                    queue_polyline_bind_group.in_set(RenderSet::Queue),
-                    queue_polyline_view_bind_groups.in_set(RenderSet::Queue),
+                    prepare_polyline_bind_group.in_set(RenderSet::PrepareBindGroups),
+                    prepare_polyline_view_bind_groups.in_set(RenderSet::PrepareBindGroups),
                 ),
             );
     }
+
+    fn finish(&self, app: &mut App) {
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app.init_resource::<PolylinePipeline>();
+    }
 }
 
 #[derive(Bundle, Default)]
@@ -60,15 +67,23 @@ pub struct PolylineBundle {
     /// User indication of whether an entity is visible
     pub visibility: Visibility,
     /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
-    pub computed_visibility: ComputedVisibility,
+    pub inherited_visibility: InheritedVisibility,
+    pub view_visibility: ViewVisibility,
 }
 
-#[derive(Debug, Default, Component, Clone, TypeUuid, TypePath)]
-#[uuid = "c76af88a-8afe-405c-9a64-0a7d845d2546"]
+#[derive(Component, Debug, Default, Clone, TypePath)]
 pub struct Polyline {
     pub vertices: Vec<Vec3>,
 }
 
+impl Asset for Polyline {}
+
+impl VisitAssetDependencies for Polyline {
+    fn visit_dependencies(&self, _: &mut impl FnMut(UntypedAssetId)) {
+        unreachable!()
+    }
+}
+
 impl RenderAsset for Polyline {
     type ExtractedAsset = Polyline;
 
@@ -82,17 +97,18 @@ impl RenderAsset for Polyline {
 
     fn prepare_asset(
         polyline: Self::ExtractedAsset,
-        render_device: &mut bevy::ecs::system::SystemParamItem<Self::Param>,
+        render_device: &mut SystemParamItem<Self::Param>,
     ) -> Result<
         Self::PreparedAsset,
         bevy::render::render_asset::PrepareAssetError<Self::ExtractedAsset>,
     > {
-        let vertex_buffer_data = cast_slice(polyline.vertices.as_slice());
-        let vertex_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
-            usage: BufferUsages::VERTEX,
-            label: Some("Polyline Vertex Buffer"),
-            contents: vertex_buffer_data,
-        });
+        let vertex_buffer_data = cast_slice(&polyline.vertices);
+        let vertex_buffer = render_device.create_buffer_with_data(
+            &BufferInitDescriptor {
+                usage: BufferUsages::VERTEX,
+                label: Some("Polyline Vertex Buffer"),
+                contents: vertex_buffer_data,
+            });
 
         Ok(GpuPolyline {
             vertex_buffer,
@@ -101,10 +117,9 @@ impl RenderAsset for Polyline {
     }
 }
 
-#[derive(Component, Clone, ShaderType)]
+#[derive(Component, ShaderType, Clone, Copy)]
 pub struct PolylineUniform {
     pub transform: Mat4,
-    //pub inverse_transpose_model: Mat4,
 }
 
 /// The GPU-representation of a [`Polyline`]
@@ -120,15 +135,15 @@ pub fn extract_polylines(
     query: Extract<
         Query<(
             Entity,
-            &ComputedVisibility,
+            &ViewVisibility,
             &GlobalTransform,
             &Handle<Polyline>,
         )>,
     >,
 ) {
     let mut values = Vec::with_capacity(*previous_len);
-    for (entity, computed_visibility, transform, handle) in query.iter() {
-        if !computed_visibility.is_visible() {
+    for (entity, visibility, transform, handle) in query.iter() {
+        if !visibility.get() {
             continue;
         }
         let transform = transform.compute_matrix();
@@ -138,7 +153,6 @@ pub fn extract_polylines(
                 handle.clone_weak(),
                 PolylineUniform {
                     transform,
-                    //inverse_transpose_model: transform.inverse().transpose(),
                 },
             ),
         ));
@@ -241,7 +255,7 @@ impl SpecializedRenderPipeline for PolylinePipeline {
 
         RenderPipelineDescriptor {
             vertex: VertexState {
-                shader: SHADER_HANDLE.typed::<Shader>(),
+                shader: SHADER_HANDLE,
                 entry_point: "vertex".into(),
                 shader_defs: shader_defs.clone(),
                 buffers: vec![VertexBufferLayout {
@@ -251,7 +265,7 @@ impl SpecializedRenderPipeline for PolylinePipeline {
                 }],
             },
             fragment: Some(FragmentState {
-                shader: SHADER_HANDLE.typed::<Shader>(),
+                shader: SHADER_HANDLE,
                 shader_defs,
                 entry_point: "fragment".into(),
                 targets: vec![Some(ColorTargetState {
@@ -339,7 +353,7 @@ pub struct PolylineBindGroup {
     pub value: BindGroup,
 }
 
-pub fn queue_polyline_bind_group(
+pub fn prepare_polyline_bind_group(
     mut commands: Commands,
     polyline_pipeline: Res<PolylinePipeline>,
     render_device: Res<RenderDevice>,
@@ -347,14 +361,11 @@ pub fn queue_polyline_bind_group(
 ) {
     if let Some(binding) = polyline_uniforms.uniforms().binding() {
         commands.insert_resource(PolylineBindGroup {
-            value: render_device.create_bind_group(&BindGroupDescriptor {
-                entries: &[BindGroupEntry {
-                    binding: 0,
-                    resource: binding,
-                }],
-                label: Some("polyline_bind_group"),
-                layout: &polyline_pipeline.polyline_layout,
-            }),
+            value: render_device.create_bind_group(
+                "polyline_bind_group",
+                &polyline_pipeline.polyline_layout,
+                &BindGroupEntries::single(binding),
+            ),
         });
     }
 }
@@ -365,7 +376,7 @@ pub struct PolylineViewBindGroup {
 }
 
 #[allow(clippy::too_many_arguments)]
-pub fn queue_polyline_view_bind_groups(
+pub fn prepare_polyline_view_bind_groups(
     mut commands: Commands,
     render_device: Res<RenderDevice>,
     polyline_pipeline: Res<PolylinePipeline>,
@@ -374,14 +385,11 @@ pub fn queue_polyline_view_bind_groups(
 ) {
     if let Some(view_binding) = view_uniforms.uniforms.binding() {
         for entity in views.iter() {
-            let view_bind_group = render_device.create_bind_group(&BindGroupDescriptor {
-                entries: &[BindGroupEntry {
-                    binding: 0,
-                    resource: view_binding.clone(),
-                }],
-                label: Some("polyline_view_bind_group"),
-                layout: &polyline_pipeline.view_layout,
-            });
+            let view_bind_group = render_device.create_bind_group(
+                "polyline_view_bind_group",
+                &polyline_pipeline.view_layout,
+                &BindGroupEntries::single(view_binding.clone()),
+            );
 
             commands.entity(entity).insert(PolylineViewBindGroup {
                 value: view_bind_group,
@@ -391,10 +399,11 @@ pub fn queue_polyline_view_bind_groups(
 }
 
 pub struct SetPolylineBindGroup<const I: usize>;
+
 impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetPolylineBindGroup<I> {
+    type Param = SRes<PolylineBindGroup>;
     type ViewWorldQuery = ();
     type ItemWorldQuery = Read<DynamicUniformIndex<PolylineUniform>>;
-    type Param = SRes<PolylineBindGroup>;
 
     #[inline]
     fn render<'w>(
@@ -410,10 +419,11 @@ impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetPolylineBindGroup<I>
 }
 
 pub struct DrawPolyline;
+
 impl<P: PhaseItem> RenderCommand<P> for DrawPolyline {
+    type Param = SRes<RenderAssets<Polyline>>;
     type ViewWorldQuery = ();
     type ItemWorldQuery = Read<Handle<Polyline>>;
-    type Param = SRes<RenderAssets<Polyline>>;
 
     #[inline]
     fn render<'w>(
diff --git a/src/shaders/polyline.wgsl b/src/shaders/polyline.wgsl
index b75a16b..c5d32ed 100644
--- a/src/shaders/polyline.wgsl
+++ b/src/shaders/polyline.wgsl
@@ -1,4 +1,4 @@
-#import bevy_render::view View
+#import bevy_render::view::View
 
 @group(0) @binding(0)
 var<uniform> view: View;
@@ -30,6 +30,18 @@ struct VertexOutput {
     @location(0) color: vec4<f32>,
 };
 
+fn clip_near_plane(a: vec4<f32>, b: vec4<f32>) -> vec4<f32> {
+    // Move a if a is behind the near plane and b is in front.
+    if a.z > a.w && b.z <= b.w {
+        // Interpolate a towards b until it's at the near plane.
+        let distance_a = a.z - a.w;
+        let distance_b = b.z - b.w;
+        let t = distance_a / (distance_a - distance_b);
+        return a + (b - a) * t;
+    }
+    return a;
+}
+
 @vertex
 fn vertex(vertex: Vertex) -> VertexOutput {
     var positions = array<vec3<f32>, 6u>(
@@ -43,8 +55,13 @@ fn vertex(vertex: Vertex) -> VertexOutput {
     let position = positions[vertex.index];
 
     // algorithm based on https://wwwtyro.net/2019/11/18/instanced-lines.html
-    let clip0 = view.view_proj * polyline.model * vec4(vertex.point_a, 1.0);
-    let clip1 = view.view_proj * polyline.model * vec4(vertex.point_b, 1.0);
+    var clip0 = view.view_proj * polyline.model * vec4(vertex.point_a, 1.0);
+    var clip1 = view.view_proj * polyline.model * vec4(vertex.point_b, 1.0);
+
+    // Manual near plane clipping to avoid errors when doing the perspective divide inside this shader.
+    clip0 = clip_near_plane(clip0, clip1);
+    clip1 = clip_near_plane(clip1, clip0);
+
     let clip = mix(clip0, clip1, position.z);
 
     let resolution = vec2(view.viewport.z, view.viewport.w);