diff --git a/examples/batching_test.rs b/examples/batching_test.rs
new file mode 100644
index 0000000..52b4304
--- /dev/null
+++ b/examples/batching_test.rs
@@ -0,0 +1,100 @@
+use bevy::{
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    prelude::*,
+};
+use bevy_polyline::{prelude::*, PolylineSettings};
+
+const SIDE_LEN: i32 = 60;
+const POLY_CUBE_SIDE_LEN: i32 = 3;
+
+fn main() {
+    App::new()
+        .insert_resource(Msaa { samples: 4 })
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            window: WindowDescriptor {
+                present_mode: bevy::window::PresentMode::Immediate,
+                ..default()
+            },
+            ..default()
+        }))
+        .add_plugin(PolylinePlugin)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_startup_system(setup)
+        .add_system(toggle_batching)
+        .add_system(rotator_system)
+        .run();
+}
+
+fn toggle_batching(mut settings: ResMut<PolylineSettings>, input: Res<Input<KeyCode>>) {
+    if input.just_pressed(KeyCode::Space) {
+        settings.batching_enabled = !settings.batching_enabled;
+        info!("Batching enabled: {}", settings.batching_enabled);
+    }
+}
+
+fn setup(mut commands: Commands, mut polyline_materials: ResMut<Assets<PolylineMaterial>>) {
+    let n_entities = SIDE_LEN.pow(3);
+    let n_lines = n_entities * POLY_CUBE_SIDE_LEN.pow(3);
+    info!("Rendering {n_entities} polyline entities, with a total of {n_lines} lines.");
+
+    let material = polyline_materials.add(PolylineMaterial {
+        width: 4.0,
+        color: Color::WHITE,
+        perspective: true,
+        ..Default::default()
+    });
+
+    let mut list = Vec::new();
+
+    for x in 0..SIDE_LEN {
+        for y in 0..SIDE_LEN {
+            for z in 0..SIDE_LEN {
+                let x = (x * 2 - SIDE_LEN / 2) as f32;
+                let y = (y * 2 - SIDE_LEN / 2) as f32;
+                let z = (z * 2 - SIDE_LEN / 2) as f32;
+
+                let poly_cube_origin = Vec3::new(x, y, z);
+
+                list.push(PolylineBundle {
+                    polyline: Polyline::new(
+                        (0..POLY_CUBE_SIDE_LEN.pow(3))
+                            .map(|i| {
+                                let ix = i % POLY_CUBE_SIDE_LEN;
+                                let iy = i / POLY_CUBE_SIDE_LEN % POLY_CUBE_SIDE_LEN;
+                                let iz = i / POLY_CUBE_SIDE_LEN.pow(2) % POLY_CUBE_SIDE_LEN;
+                                Vec3::new(ix as f32, iy as f32, iz as f32)
+                                    / (POLY_CUBE_SIDE_LEN as f32)
+                                    + poly_cube_origin
+                            })
+                            .collect(),
+                    ),
+                    material: material.clone(),
+                    ..Default::default()
+                });
+            }
+        }
+    }
+    commands.spawn_batch(list);
+
+    // camera
+    commands.spawn((
+        Camera3dBundle {
+            transform: Transform::from_xyz(-2.0, 2.5, -5.0).looking_at(Vec3::ZERO, Vec3::Y),
+            ..Camera3dBundle::default()
+        },
+        Rotates,
+    ));
+}
+
+/// this component indicates what entities should rotate
+#[derive(Component)]
+struct Rotates;
+
+fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
+    for mut transform in query.iter_mut() {
+        *transform = Transform::from_rotation(Quat::from_rotation_y(
+            (4.0 * std::f32::consts::PI / 50.0) * time.delta_seconds(),
+        )) * *transform;
+    }
+}
diff --git a/examples/depth_bias.rs b/examples/depth_bias.rs
index d30389a..019bd77 100644
--- a/examples/depth_bias.rs
+++ b/examples/depth_bias.rs
@@ -58,7 +58,6 @@ fn setup(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut pbr_materials: ResMut<Assets<StandardMaterial>>,
-    mut polylines: ResMut<Assets<Polyline>>,
     mut materials: ResMut<Assets<PolylineMaterial>>,
 ) {
     commands
@@ -76,9 +75,9 @@ fn setup(
     let bottom = Vec3::Y * -100.0;
     // Show the middle as a vertical red bar.
     commands.spawn(PolylineBundle {
-        polyline: polylines.add(Polyline {
+        polyline: Polyline {
             vertices: vec![top, bottom],
-        }),
+        },
         material: materials.add(PolylineMaterial {
             width: 5.0,
             color: Color::RED,
@@ -94,9 +93,7 @@ fn setup(
         let left = Vec3::new(0.0, bias * 35.0, -500.0);
         let right = Vec3::new(0.0, bias * 35.0, 500.0);
         commands.spawn(PolylineBundle {
-            polyline: polylines.add(Polyline {
-                vertices: vec![left, right],
-            }),
+            polyline: Polyline::new(vec![left, right]),
             material: materials.add(PolylineMaterial {
                 width: 1.0,
                 color: Color::hsl((bias + 1.0) / 2.0 * 270.0, 1.0, 0.5),
diff --git a/examples/linestrip.rs b/examples/linestrip.rs
index c0059d9..d62020a 100644
--- a/examples/linestrip.rs
+++ b/examples/linestrip.rs
@@ -16,22 +16,18 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut standard_materials: ResMut<Assets<StandardMaterial>>,
     mut polyline_materials: ResMut<Assets<PolylineMaterial>>,
-    mut polylines: ResMut<Assets<Polyline>>,
 ) {
     commands.spawn(PolylineBundle {
-        polyline: polylines.add(Polyline {
-            vertices: vec![
-                Vec3::new(-0.5, -0.5, -0.5),
-                Vec3::new(0.5, -0.5, -0.5),
-                Vec3::new(0.5, 0.5, -0.5),
-                Vec3::new(-0.5, 0.5, -0.5),
-                Vec3::new(-0.5, 0.5, 0.5),
-                Vec3::new(0.5, 0.5, 0.5),
-                Vec3::new(0.5, -0.5, 0.5),
-                Vec3::new(-0.5, -0.5, 0.5),
-            ],
-            ..Default::default()
-        }),
+        polyline: Polyline::new(vec![
+            Vec3::new(-0.5, -0.5, -0.5),
+            Vec3::new(0.5, -0.5, -0.5),
+            Vec3::new(0.5, 0.5, -0.5),
+            Vec3::new(-0.5, 0.5, -0.5),
+            Vec3::new(-0.5, 0.5, 0.5),
+            Vec3::new(0.5, 0.5, 0.5),
+            Vec3::new(0.5, -0.5, 0.5),
+            Vec3::new(-0.5, -0.5, 0.5),
+        ]),
         material: polyline_materials.add(PolylineMaterial {
             width: 2.0,
             color: Color::RED,
diff --git a/examples/minimal.rs b/examples/minimal.rs
index 724d89b..3324cab 100644
--- a/examples/minimal.rs
+++ b/examples/minimal.rs
@@ -9,16 +9,9 @@ fn main() {
         .run();
 }
 
-fn setup(
-    mut commands: Commands,
-    mut polyline_materials: ResMut<Assets<PolylineMaterial>>,
-    mut polylines: ResMut<Assets<Polyline>>,
-) {
+fn setup(mut commands: Commands, mut polyline_materials: ResMut<Assets<PolylineMaterial>>) {
     commands.spawn(PolylineBundle {
-        polyline: polylines.add(Polyline {
-            vertices: vec![-Vec3::ONE, Vec3::ONE],
-            ..Default::default()
-        }),
+        polyline: Polyline::new(vec![-Vec3::ONE, Vec3::ONE]),
         material: polyline_materials.add(PolylineMaterial {
             width: 10.0,
             color: Color::RED,
diff --git a/examples/nbody.rs b/examples/nbody.rs
index 07cbc63..3d92ece 100644
--- a/examples/nbody.rs
+++ b/examples/nbody.rs
@@ -12,7 +12,7 @@ use lazy_static::*;
 use rand::{prelude::*, Rng};
 use ringbuffer::{ConstGenericRingBuffer, RingBufferExt, RingBufferWrite};
 
-const NUM_BODIES: usize = 512;
+const NUM_BODIES: usize = 256;
 const TRAIL_LENGTH: usize = 1024;
 const MINIMUM_ANGLE: f32 = 1.48341872; // == acos(5 degrees)
 
@@ -21,7 +21,7 @@ fn main() {
         .insert_resource(ClearColor(Color::BLACK))
         .insert_resource(Msaa { samples: 4 })
         .insert_resource(Simulation {
-            scale: 1e5,
+            scale: 4e5,
             ..Default::default()
         })
         .add_plugins(DefaultPlugins.set(WindowPlugin {
@@ -44,12 +44,9 @@ fn main() {
         .run();
 }
 
-fn setup(
-    mut commands: Commands,
-    mut polyline_materials: ResMut<Assets<PolylineMaterial>>,
-    mut polylines: ResMut<Assets<Polyline>>,
-) {
+fn setup(mut commands: Commands, mut polyline_materials: ResMut<Assets<PolylineMaterial>>) {
     let mut rng = StdRng::seed_from_u64(0);
+
     for _index in 0..NUM_BODIES {
         let r = rng.gen_range(2f32..800f32);
         let theta = rng.gen_range(0f32..2.0 * PI);
@@ -59,6 +56,7 @@ fn setup(
             r * f32::sin(theta),
         );
         let size = rng.gen_range(50f32..1000f32);
+
         commands.spawn((
             Body {
                 mass: size,
@@ -68,9 +66,7 @@ fn setup(
             },
             Trail(ConstGenericRingBuffer::<Vec3A, TRAIL_LENGTH>::new()),
             PolylineBundle {
-                polyline: polylines.add(Polyline {
-                    vertices: Vec::with_capacity(TRAIL_LENGTH),
-                }),
+                polyline: Polyline::new(Vec::with_capacity(TRAIL_LENGTH)),
                 material: polyline_materials.add(PolylineMaterial {
                     width: (size * 0.1).powf(1.8),
                     color: Color::hsl(rng.gen_range(0.0..360.0), 1.0, rng.gen_range(0.4..2.0)),
@@ -167,7 +163,7 @@ const EPSILON: f32 = 1.;
 fn nbody_system(
     time: Res<Time>,
     mut simulation: ResMut<Simulation>,
-    mut query: Query<(Entity, &mut Body, &mut Trail, &Handle<Polyline>)>,
+    mut query: Query<(Entity, &mut Body, &mut Trail, &Polyline)>,
 ) {
     let mut bodies = query.iter_mut().collect::<Vec<_>>();
     // dbg!(&bodies);
@@ -212,11 +208,8 @@ fn nbody_system(
     }
 }
 
-fn update_trails(
-    mut polylines: ResMut<Assets<Polyline>>,
-    mut query: Query<(&Body, &mut Trail, &Handle<Polyline>)>,
-) {
-    query.for_each_mut(|(body, mut trail, polyline)| {
+fn update_trails(mut query: Query<(&Body, &mut Trail, &mut Polyline)>) {
+    query.for_each_mut(|(body, mut trail, mut 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) {
@@ -227,24 +220,17 @@ fn update_trails(
             let gt_min_angle = last_vec.dot(last_last_vec) > MINIMUM_ANGLE;
             if gt_min_angle {
                 trail.0.push(body.position);
-                polylines.get_mut(polyline).unwrap().vertices =
-                    trail.0.iter().map(|v| Vec3::from(*v)).collect()
+                polyline.vertices = trail.0.iter().map(|v| Vec3::from(*v)).collect()
             } 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 {
+                if polyline.vertices.len() > 1 {
                     *trail.0.get_mut(-1).unwrap() = body.position;
-                    *polylines
-                        .get_mut(polyline)
-                        .unwrap()
-                        .vertices
-                        .last_mut()
-                        .unwrap() = body.position.into();
+                    *polyline.vertices.last_mut().unwrap() = body.position.into();
                 }
             }
         } else {
             trail.0.push(body.position);
-            polylines.get_mut(polyline).unwrap().vertices =
-                trail.0.iter().map(|v| Vec3::from(*v)).collect()
+            polyline.vertices = trail.0.iter().map(|v| Vec3::from(*v)).collect()
         }
     });
 }
diff --git a/src/lib.rs b/src/lib.rs
index c4220d0..d9557d6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,6 +17,18 @@ pub mod prelude {
 pub const SHADER_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 12823766040132746065);
 
+#[derive(Resource)]
+pub struct PolylineSettings {
+    pub batching_enabled: bool,
+}
+impl Default for PolylineSettings {
+    fn default() -> Self {
+        Self {
+            batching_enabled: true,
+        }
+    }
+}
+
 pub struct PolylinePlugin;
 
 impl Plugin for PolylinePlugin {
diff --git a/src/material.rs b/src/material.rs
index 0b180af..416d750 100644
--- a/src/material.rs
+++ b/src/material.rs
@@ -180,7 +180,6 @@ pub struct PolylineMaterialPlugin;
 impl Plugin for PolylineMaterialPlugin {
     fn build(&self, app: &mut App) {
         app.add_asset::<PolylineMaterial>()
-            .add_plugin(ExtractComponentPlugin::<Handle<PolylineMaterial>>::default())
             .add_plugin(RenderAssetPlugin::<PolylineMaterial>::default());
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app
diff --git a/src/polyline.rs b/src/polyline.rs
index 7be2ffa..bcd1779 100644
--- a/src/polyline.rs
+++ b/src/polyline.rs
@@ -1,4 +1,4 @@
-use crate::{material::PolylineMaterial, SHADER_HANDLE};
+use crate::{material::PolylineMaterial, PolylineSettings, SHADER_HANDLE};
 use bevy::{
     core::cast_slice,
     ecs::system::{
@@ -15,24 +15,28 @@ use bevy::{
         render_resource::*,
         renderer::RenderDevice,
         texture::BevyDefault,
-        view::{ViewUniform, ViewUniforms},
+        view::{NoFrustumCulling, ViewUniform, ViewUniforms},
         Extract, RenderApp, RenderStage,
     },
+    utils::HashMap,
 };
 
 pub struct PolylineBasePlugin;
 
 impl Plugin for PolylineBasePlugin {
     fn build(&self, app: &mut App) {
-        app.add_asset::<Polyline>()
-            .add_plugin(RenderAssetPlugin::<Polyline>::default());
+        app.init_resource::<PolylineSettings>()
+            .add_asset::<RenderPolyline>()
+            .add_plugin(RenderAssetPlugin::<RenderPolyline>::default());
     }
 }
 
 pub struct PolylineRenderPlugin;
 impl Plugin for PolylineRenderPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugin(UniformComponentPlugin::<PolylineUniform>::default());
+        app.add_plugin(UniformComponentPlugin::<PolylineUniform>::default())
+            .add_system_to_stage(CoreStage::PostUpdate, update_render_polylines);
+
         app.sub_app_mut(RenderApp)
             .init_resource::<PolylinePipeline>()
             .add_system_to_stage(RenderStage::Extract, extract_polylines)
@@ -41,9 +45,9 @@ impl Plugin for PolylineRenderPlugin {
     }
 }
 
-#[derive(Bundle, Default)]
+#[derive(Bundle)]
 pub struct PolylineBundle {
-    pub polyline: Handle<Polyline>,
+    pub polyline: Polyline,
     pub material: Handle<PolylineMaterial>,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
@@ -51,16 +55,154 @@ pub struct PolylineBundle {
     pub visibility: Visibility,
     /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
     pub computed_visibility: ComputedVisibility,
+    pub no_frustum_culling: NoFrustumCulling,
+}
+
+impl Default for PolylineBundle {
+    fn default() -> Self {
+        Self {
+            polyline: Default::default(),
+            material: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+            visibility: Default::default(),
+            computed_visibility: Default::default(),
+            no_frustum_culling: NoFrustumCulling,
+        }
+    }
+}
+
+#[derive(Debug, Default, Component, Clone)]
+pub struct Polyline {
+    pub vertices: Vec<Vec3>,
+}
+
+impl Polyline {
+    pub fn new(vertices: Vec<Vec3>) -> Self {
+        Self { vertices }
+    }
+}
+
+#[derive(Resource)]
+pub struct BatchedPolylines {
+    map: HashMap<Handle<PolylineMaterial>, HashMap<Entity, Vec<Vec3>>>,
+}
+
+pub fn update_render_polylines(
+    settings: Res<PolylineSettings>,
+    mut render_polylines: ResMut<Assets<RenderPolyline>>,
+    mut polylines: ParamSet<(
+        Query<
+            (
+                Entity,
+                &Polyline,
+                &mut Handle<RenderPolyline>,
+                &Handle<PolylineMaterial>,
+                &GlobalTransform,
+            ),
+            Or<(
+                Changed<GlobalTransform>,
+                Changed<Handle<PolylineMaterial>>,
+                Changed<Polyline>,
+            )>,
+        >,
+        Query<(
+            Entity,
+            &Polyline,
+            &mut Handle<RenderPolyline>,
+            &Handle<PolylineMaterial>,
+            &GlobalTransform,
+        )>,
+    )>,
+    mut map: ResMut<BatchedPolylines>,
+) {
+    if settings.is_changed() {
+        for (entity, polyline, render_polyline, matl, transform) in &mut polylines.p1() {
+            batch_polylines(
+                &settings,
+                &mut map,
+                matl,
+                polyline,
+                transform,
+                entity,
+                render_polyline,
+                &mut render_polylines,
+            );
+        }
+    } else {
+        for (entity, polyline, render_polyline, matl, transform) in &mut polylines.p0() {
+            batch_polylines(
+                &settings,
+                &mut map,
+                matl,
+                polyline,
+                transform,
+                entity,
+                render_polyline,
+                &mut render_polylines,
+            );
+        }
+    }
+}
+
+fn batch_polylines(
+    settings: &Res<PolylineSettings>,
+    batched_polylines: &mut ResMut<BatchedPolylines>,
+    matl: &Handle<PolylineMaterial>,
+    polyline: &Polyline,
+    transform: &GlobalTransform,
+    entity: Entity,
+    mut render_polyline: Mut<Handle<RenderPolyline>>,
+    render_polylines: &mut ResMut<Assets<RenderPolyline>>,
+) {
+    if settings.batching_enabled {
+        batched_polylines
+            .map
+            .entry(matl.to_owned())
+            .and_modify(|entry: &mut HashMap<Entity, Vec<Vec3>>| {
+                entry.insert(
+                    entity,
+                    polyline
+                        .vertices
+                        .iter()
+                        .map(|v| transform.transform_point(*v))
+                        .collect(),
+                );
+            })
+            .or_insert({
+                let mut hashmap = HashMap::new();
+                hashmap.insert(
+                    entity,
+                    polyline
+                        .vertices
+                        .iter()
+                        .map(|v| transform.transform_point(*v))
+                        .collect(),
+                );
+                hashmap
+            });
+        *render_polyline = Handle::default();
+    } else {
+        *render_polyline = render_polylines.add(polyline.into());
+    }
 }
 
 #[derive(Debug, Default, Component, Clone, TypeUuid)]
 #[uuid = "c76af88a-8afe-405c-9a64-0a7d845d2546"]
-pub struct Polyline {
+pub struct RenderPolyline {
     pub vertices: Vec<Vec3>,
 }
 
-impl RenderAsset for Polyline {
-    type ExtractedAsset = Polyline;
+impl From<&Polyline> for RenderPolyline {
+    fn from(polyline: &Polyline) -> Self {
+        RenderPolyline {
+            vertices: polyline.vertices.clone(),
+        }
+    }
+}
+
+impl RenderAsset for RenderPolyline {
+    type ExtractedAsset = RenderPolyline;
 
     type PreparedAsset = GpuPolyline;
 
@@ -104,21 +246,23 @@ pub struct GpuPolyline {
     pub vertex_count: u32,
 }
 
+//TODO: currently converting this from a query to building polyline assets from the batched polyline resource.
 pub fn extract_polylines(
     mut commands: Commands,
     mut previous_len: Local<usize>,
-    query: Extract<
-        Query<(
-            Entity,
-            &ComputedVisibility,
-            &GlobalTransform,
-            &Handle<Polyline>,
-        )>,
-    >,
+    batched_polylines: Extract<Res<BatchedPolylines>>,
 ) {
     let mut values = Vec::with_capacity(*previous_len);
-    for (entity, computed_visibility, transform, handle) in query.iter() {
-        if !computed_visibility.is_visible() {
+    for (matl, map) in batched_polylines.map.iter() {
+        let mut verts = Vec::new();
+        for group in map.values() {
+            verts.append(&mut group.to_owned());
+            verts.push(Vec3::NAN);
+        }
+        values.push
+    }
+    for (entity, computed_visibility, transform, handle, matl) in query.iter() {
+        if !computed_visibility.is_visible() || *handle == Handle::default() {
             continue;
         }
         let transform = transform.compute_matrix();
@@ -126,10 +270,8 @@ pub fn extract_polylines(
             entity,
             (
                 handle.clone_weak(),
-                PolylineUniform {
-                    transform,
-                    //inverse_transpose_model: transform.inverse().transpose(),
-                },
+                matl.clone_weak(),
+                PolylineUniform { transform },
             ),
         ));
     }
@@ -457,7 +599,10 @@ impl<const I: usize> EntityRenderCommand for SetPolylineBindGroup<I> {
 
 pub struct DrawPolyline;
 impl EntityRenderCommand for DrawPolyline {
-    type Param = (SRes<RenderAssets<Polyline>>, SQuery<Read<Handle<Polyline>>>);
+    type Param = (
+        SRes<RenderAssets<RenderPolyline>>,
+        SQuery<Read<Handle<RenderPolyline>>>,
+    );
     #[inline]
     fn render<'w>(
         _view: Entity,