diff --git a/README.md b/README.md
index 9bbc8a19..ad6b0fa1 100644
--- a/README.md
+++ b/README.md
@@ -90,7 +90,7 @@ fn setup(mut effects: ResMut<Assets<EffectAsset>>) {
   // Create the effect asset
   let effect = EffectAsset::new(
     // Maximum number of particles alive at a time
-    vec![32768],
+    32768,
     // Spawn at a rate of 5 particles per second
     Spawner::rate(5.0.into()),
     // Move the expression module into the asset
diff --git a/examples/2d.rs b/examples/2d.rs
index 4f4d67d9..aa755644 100644
--- a/examples/2d.rs
+++ b/examples/2d.rs
@@ -85,7 +85,7 @@ fn setup(
     // By default the asset spawns the particles at Z=0.
     let spawner = Spawner::rate(30.0.into());
     let effect = effects.add(
-        EffectAsset::new(vec![4096], spawner, module)
+        EffectAsset::new(4096, spawner, module)
             .with_name("2d")
             .init(init_pos)
             .init(init_vel)
diff --git a/examples/activate.rs b/examples/activate.rs
index 9ca0ccea..202582fb 100644
--- a/examples/activate.rs
+++ b/examples/activate.rs
@@ -115,7 +115,7 @@ fn setup(
     let round = RoundModifier::constant(&mut module, 1.0);
 
     let effect = effects.add(
-        EffectAsset::new(vec![32768], spawner, module)
+        EffectAsset::new(32768, spawner, module)
             .with_name("activate")
             .init(init_pos)
             .init(init_vel)
@@ -159,7 +159,7 @@ fn setup(
 
 fn update(
     mut q_balls: Query<(&mut Ball, &mut Transform, &Children)>,
-    mut q_spawner: Query<&mut EffectSpawner>,
+    mut q_spawner: Query<&mut EffectInitializers>,
     mut q_text: Query<&mut Text, With<StatusText>>,
     time: Res<Time>,
 ) {
diff --git a/examples/billboard.rs b/examples/billboard.rs
index 977c5fc5..8730ef3a 100644
--- a/examples/billboard.rs
+++ b/examples/billboard.rs
@@ -117,7 +117,7 @@ fn setup(
     module.add_texture("color");
 
     let effect = effects.add(
-        EffectAsset::new(vec![32768], Spawner::rate(64.0.into()), module)
+        EffectAsset::new(32768, Spawner::rate(64.0.into()), module)
             .with_name("billboard")
             .with_alpha_mode(bevy_hanabi::AlphaMode::Mask(alpha_cutoff))
             .init(init_pos)
diff --git a/examples/circle.rs b/examples/circle.rs
index 3fa04494..2b362370 100644
--- a/examples/circle.rs
+++ b/examples/circle.rs
@@ -112,7 +112,7 @@ fn setup(
     module.add_texture("color");
 
     let effect = effects.add(
-        EffectAsset::new(vec![32768], Spawner::burst(32.0.into(), 8.0.into()), module)
+        EffectAsset::new(32768, Spawner::burst(32.0.into(), 8.0.into()), module)
             .with_name("circle")
             .init(init_pos)
             .init(init_vel)
diff --git a/examples/expr.rs b/examples/expr.rs
index 402f6814..8f22c161 100644
--- a/examples/expr.rs
+++ b/examples/expr.rs
@@ -82,7 +82,7 @@ fn setup(mut commands: Commands, mut effects: ResMut<Assets<EffectAsset>>) {
     };
 
     let effect = effects.add(
-        EffectAsset::new(vec![32768], Spawner::rate(500.0.into()), writer.finish())
+        EffectAsset::new(32768, Spawner::rate(500.0.into()), writer.finish())
             .with_name("whirlwind")
             .init(init_pos)
             .init(init_age)
diff --git a/examples/firework.rs b/examples/firework.rs
index 14887161..43c6fba6 100644
--- a/examples/firework.rs
+++ b/examples/firework.rs
@@ -14,9 +14,8 @@
 //! - An [`AccelModifier`] to pull particles down once they slow down, for
 //!   increased realism. This is a subtle effect, but of importance.
 //!
-//! The particles also have a trail, created with the [`CloneModifier`]. The
-//! trail particles are stitched together to form an arc using the
-//! [`RibbonModifier`].
+//! The particles also have a trail. The trail particles are stitched together
+//! to form an arc using [`EffectAsset::with_ribbons`].
 
 use bevy::{
     core_pipeline::{bloom::BloomSettings, tonemapping::Tonemapping},
@@ -74,10 +73,6 @@ fn setup(mut commands: Commands, mut effects: ResMut<Assets<EffectAsset>>) {
     let lifetime = writer.lit(0.8).normal(writer.lit(1.2)).expr();
     let init_lifetime = SetAttributeModifier::new(Attribute::LIFETIME, lifetime);
 
-    // Lifetime for trails
-    let init_lifetime_trails =
-        SetAttributeModifier::new(Attribute::LIFETIME, writer.lit(0.2).expr());
-
     // Add constant downward acceleration to simulate gravity
     let accel = writer.lit(Vec3::Y * -16.).expr();
     let update_accel = AccelModifier::new(accel);
@@ -108,23 +103,21 @@ fn setup(mut commands: Commands, mut effects: ResMut<Assets<EffectAsset>>) {
 
     let effect = EffectAsset::new(
         // 2k lead particles, with 32 trail particles each
-        vec![2048, 2048 * 32],
+        2048,
         Spawner::burst(2048.0.into(), 2.0.into()),
         writer.finish(),
     )
+    // Tie together trail particles to make arcs. This way we don't need a lot of them, yet there's
+    // a continuity between them.
+    .with_ribbons(2048 * 32, 1.0 / 64.0, 0.2, 0)
     .with_name("firework")
-    .init(init_pos)
-    .init(init_vel)
-    .init(init_age)
-    .init(init_lifetime)
-    .update_groups(CloneModifier::new(1.0 / 64.0, 1), lead)
+    .init_groups(init_pos, lead)
+    .init_groups(init_vel, lead)
+    .init_groups(init_age, lead)
+    .init_groups(init_lifetime, lead)
+    .init_groups(init_vel_trail, trail)
     .update_groups(update_drag, lead)
     .update_groups(update_accel, lead)
-    // Currently the init pass doesn't run on cloned particles, so we have to use an update modifier
-    // to init the lifetime of trails. This will overwrite the value each frame, so can only be used
-    // for constant values.
-    .update_groups(init_lifetime_trails, trail)
-    .update_groups(init_vel_trail, trail)
     .render_groups(
         ColorOverLifetimeModifier {
             gradient: color_gradient1.clone(),
@@ -150,10 +143,7 @@ fn setup(mut commands: Commands, mut effects: ResMut<Assets<EffectAsset>>) {
             screen_space_size: false,
         },
         trail,
-    )
-    // Tie together trail particles to make arcs. This way we don't need a lot of them, yet there's
-    // a continuity between them.
-    .render_groups(RibbonModifier, trail);
+    );
 
     let effect1 = effects.add(effect);
 
diff --git a/examples/force_field.rs b/examples/force_field.rs
index 055c05be..61037c81 100644
--- a/examples/force_field.rs
+++ b/examples/force_field.rs
@@ -308,7 +308,7 @@ fn setup(
 
     // Force field effects
     let effect = effects.add(
-        EffectAsset::new(vec![32768], spawner, writer.finish())
+        EffectAsset::new(32768, spawner, writer.finish())
             .with_name("force_field")
             .init(init_pos)
             .init(init_vel)
@@ -329,7 +329,7 @@ fn setup(
 }
 
 fn spawn_on_click(
-    mut q_effect: Query<(&mut EffectSpawner, &mut Transform), Without<Projection>>,
+    mut q_effect: Query<(&mut EffectInitializers, &mut Transform), Without<Projection>>,
     mouse_button_input: Res<ButtonInput<MouseButton>>,
     camera_query: Query<(&Camera, &GlobalTransform), With<Projection>>,
     window: Query<&Window, With<bevy::window::PrimaryWindow>>,
@@ -337,7 +337,7 @@ fn spawn_on_click(
     // Note: On first frame where the effect spawns, EffectSpawner is spawned during
     // CoreSet::PostUpdate, so will not be available yet. Ignore for a frame if
     // so.
-    let Ok((mut spawner, mut effect_transform)) = q_effect.get_single_mut() else {
+    let Ok((mut initializers, mut effect_transform)) = q_effect.get_single_mut() else {
         return;
     };
 
@@ -354,7 +354,7 @@ fn spawn_on_click(
                 effect_transform.translation = spawning_pos;
 
                 // Spawn a single burst of particles
-                spawner.reset();
+                initializers.reset();
             }
         }
     }
diff --git a/examples/gradient.rs b/examples/gradient.rs
index f3e2b184..c1912fe2 100644
--- a/examples/gradient.rs
+++ b/examples/gradient.rs
@@ -72,7 +72,7 @@ fn setup(
     module.add_texture("color");
 
     let effect = effects.add(
-        EffectAsset::new(vec![32768], Spawner::rate(1000.0.into()), module)
+        EffectAsset::new(32768, Spawner::rate(1000.0.into()), module)
             .with_name("gradient")
             .init(init_pos)
             .init(init_vel)
diff --git a/examples/init.rs b/examples/init.rs
index ac3e44fd..3b153c7d 100644
--- a/examples/init.rs
+++ b/examples/init.rs
@@ -36,19 +36,15 @@ where
 
     let init = make_modifier(&writer);
 
-    EffectAsset::new(
-        vec![32768],
-        Spawner::once(COUNT.into(), true),
-        writer.finish(),
-    )
-    .with_name(name)
-    .with_simulation_space(SimulationSpace::Local)
-    .init(init)
-    .render(OrientModifier::new(OrientMode::FaceCameraPosition))
-    .render(SetColorModifier {
-        color: COLOR.into(),
-    })
-    .render(SetSizeModifier { size: SIZE.into() })
+    EffectAsset::new(32768, Spawner::once(COUNT.into(), true), writer.finish())
+        .with_name(name)
+        .with_simulation_space(SimulationSpace::Local)
+        .init(init)
+        .render(OrientModifier::new(OrientMode::FaceCameraPosition))
+        .render(SetColorModifier {
+            color: COLOR.into(),
+        })
+        .render(SetSizeModifier { size: SIZE.into() })
 }
 
 fn spawn_effect(
diff --git a/examples/instancing.rs b/examples/instancing.rs
index c4ef46cd..61cabc71 100644
--- a/examples/instancing.rs
+++ b/examples/instancing.rs
@@ -248,7 +248,7 @@ fn setup(
     };
 
     let effect = effects.add(
-        EffectAsset::new(vec![512], Spawner::rate(50.0.into()), writer.finish())
+        EffectAsset::new(512, Spawner::rate(50.0.into()), writer.finish())
             .with_name("instancing")
             .init(init_pos)
             .init(init_vel)
@@ -288,7 +288,7 @@ fn setup(
     module.add_texture("color");
 
     let alt_effect = effects.add(
-        EffectAsset::new(vec![512], Spawner::rate(102.0.into()), module)
+        EffectAsset::new(512, Spawner::rate(102.0.into()), module)
             .with_simulation_space(SimulationSpace::Local)
             .with_name("alternate instancing")
             .init(init_pos)
diff --git a/examples/lifetime.rs b/examples/lifetime.rs
index 628ea07c..09e12d3c 100644
--- a/examples/lifetime.rs
+++ b/examples/lifetime.rs
@@ -81,7 +81,7 @@ fn setup(
     };
     let effect1 = effects.add(
         EffectAsset::new(
-            vec![512],
+            512,
             Spawner::burst(50.0.into(), period.into()),
             writer1.finish(),
         )
@@ -136,7 +136,7 @@ fn setup(
     };
     let effect2 = effects.add(
         EffectAsset::new(
-            vec![512],
+            512,
             Spawner::burst(50.0.into(), period.into()),
             writer2.finish(),
         )
@@ -191,7 +191,7 @@ fn setup(
     };
     let effect3 = effects.add(
         EffectAsset::new(
-            vec![512],
+            512,
             Spawner::burst(50.0.into(), period.into()),
             writer3.finish(),
         )
diff --git a/examples/multicam.rs b/examples/multicam.rs
index 15d401e7..6c9f0953 100644
--- a/examples/multicam.rs
+++ b/examples/multicam.rs
@@ -68,7 +68,7 @@ fn make_effect(color: Color) -> EffectAsset {
         speed: writer.lit(6.).expr(),
     };
 
-    EffectAsset::new(vec![32768], Spawner::rate(5.0.into()), writer.finish())
+    EffectAsset::new(32768, Spawner::rate(5.0.into()), writer.finish())
         .with_name("effect")
         .init(init_pos)
         .init(init_vel)
diff --git a/examples/ordering.rs b/examples/ordering.rs
index 9d2fa433..c579bc39 100644
--- a/examples/ordering.rs
+++ b/examples/ordering.rs
@@ -72,7 +72,7 @@ fn make_firework() -> EffectAsset {
         speed: (writer.rand(ScalarType::Float) * writer.lit(20.) + writer.lit(60.)).expr(),
     };
 
-    EffectAsset::new(vec![2048], Spawner::rate(128.0.into()), writer.finish())
+    EffectAsset::new(2048, Spawner::rate(128.0.into()), writer.finish())
         .with_name("firework")
         .init(init_pos)
         .init(init_vel)
diff --git a/examples/portal.rs b/examples/portal.rs
index 7042fa96..af1b6f8f 100644
--- a/examples/portal.rs
+++ b/examples/portal.rs
@@ -77,7 +77,7 @@ fn setup(mut commands: Commands, mut effects: ResMut<Assets<EffectAsset>>) {
     let tangent_accel = TangentAccelModifier::constant(&mut module, Vec3::ZERO, Vec3::Z, 30.);
 
     let effect1 = effects.add(
-        EffectAsset::new(vec![16384, 16384], Spawner::rate(5000.0.into()), module)
+        EffectAsset::new(16384, Spawner::rate(5000.0.into()), module)
             .with_name("portal")
             .init(init_pos)
             .init(init_age)
diff --git a/examples/random.rs b/examples/random.rs
index 08f975c8..048bc015 100644
--- a/examples/random.rs
+++ b/examples/random.rs
@@ -71,7 +71,7 @@ fn setup(
 
     let effect = effects.add(
         EffectAsset::new(
-            vec![32768],
+            32768,
             Spawner::burst(CpuValue::Uniform((1., 100.)), CpuValue::Uniform((1., 4.))),
             writer.finish(),
         )
diff --git a/examples/ribbon.rs b/examples/ribbon.rs
index 218af554..3aa805d8 100644
--- a/examples/ribbon.rs
+++ b/examples/ribbon.rs
@@ -71,8 +71,6 @@ fn setup(mut commands: Commands, mut effects: ResMut<Assets<EffectAsset>>) {
         value: writer.lit(0.5).expr(),
     };
 
-    let clone_modifier = CloneModifier::new(1.0 / TRAIL_SPAWN_RATE, 1);
-
     let time = writer.time().mul(writer.lit(TIME_SCALE));
 
     let move_modifier = SetAttributeModifier {
@@ -87,32 +85,21 @@ fn setup(mut commands: Commands, mut effects: ResMut<Assets<EffectAsset>>) {
         .expr(),
     };
 
-    let update_lifetime_attr = SetAttributeModifier {
-        attribute: Attribute::LIFETIME,
-        value: writer.lit(LIFETIME).expr(),
-    };
-
     let render_color = ColorOverLifetimeModifier {
         gradient: Gradient::linear(vec4(3.0, 0.0, 0.0, 1.0), vec4(3.0, 0.0, 0.0, 0.0)),
     };
 
-    let effect = EffectAsset::new(
-        vec![256, 32768],
-        Spawner::once(1.0.into(), true),
-        writer.finish(),
-    )
-    .with_name("ribbon")
-    .with_simulation_space(SimulationSpace::Global)
-    .init(init_position_attr)
-    .init(init_velocity_attr)
-    .init(init_age_attr)
-    .init(init_lifetime_attr)
-    .init(init_size_attr)
-    .update_groups(move_modifier, ParticleGroupSet::single(0))
-    .update_groups(clone_modifier, ParticleGroupSet::single(0))
-    .update_groups(update_lifetime_attr, ParticleGroupSet::single(1))
-    .render(RibbonModifier)
-    .render_groups(render_color, ParticleGroupSet::single(1));
+    let effect = EffectAsset::new(256, Spawner::once(1.0.into(), true), writer.finish())
+        .with_ribbons(32768, 1.0 / TRAIL_SPAWN_RATE, LIFETIME, 0)
+        .with_name("ribbon")
+        .with_simulation_space(SimulationSpace::Global)
+        .init_groups(init_position_attr, ParticleGroupSet::single(0))
+        .init_groups(init_velocity_attr, ParticleGroupSet::single(0))
+        .init_groups(init_age_attr, ParticleGroupSet::single(0))
+        .init_groups(init_lifetime_attr, ParticleGroupSet::single(0))
+        .init_groups(init_size_attr, ParticleGroupSet::single(0))
+        .update_groups(move_modifier, ParticleGroupSet::single(0))
+        .render_groups(render_color, ParticleGroupSet::single(1));
 
     let effect = effects.add(effect);
 
diff --git a/examples/spawn.rs b/examples/spawn.rs
index b4b99d29..e1d1a0aa 100644
--- a/examples/spawn.rs
+++ b/examples/spawn.rs
@@ -105,7 +105,7 @@ fn setup(
     };
 
     let effect1 = effects.add(
-        EffectAsset::new(vec![32768], Spawner::rate(500.0.into()), writer1.finish())
+        EffectAsset::new(32768, Spawner::rate(500.0.into()), writer1.finish())
             .with_name("emit:rate")
             .init(init_pos1)
             // Make spawned particles move away from the emitter origin
@@ -163,19 +163,15 @@ fn setup(
         speed: writer2.lit(2.).expr(),
     };
     let effect2 = effects.add(
-        EffectAsset::new(
-            vec![32768],
-            Spawner::once(1000.0.into(), true),
-            writer2.finish(),
-        )
-        .with_name("emit:once")
-        .init(init_pos2)
-        .init(init_vel2)
-        .init(init_age2)
-        .init(init_lifetime2)
-        .render(ColorOverLifetimeModifier {
-            gradient: gradient2,
-        }),
+        EffectAsset::new(32768, Spawner::once(1000.0.into(), true), writer2.finish())
+            .with_name("emit:once")
+            .init(init_pos2)
+            .init(init_vel2)
+            .init(init_age2)
+            .init(init_lifetime2)
+            .render(ColorOverLifetimeModifier {
+                gradient: gradient2,
+            }),
     );
 
     commands
@@ -236,7 +232,7 @@ fn setup(
 
     let effect3 = effects.add(
         EffectAsset::new(
-            vec![32768],
+            32768,
             Spawner::burst(400.0.into(), 3.0.into()),
             writer3.finish(),
         )
diff --git a/examples/spawn_on_command.rs b/examples/spawn_on_command.rs
index 4abf1825..81eefc20 100644
--- a/examples/spawn_on_command.rs
+++ b/examples/spawn_on_command.rs
@@ -133,7 +133,7 @@ fn setup(
     let init_vel = SetAttributeModifier::new(Attribute::VELOCITY, velocity.expr());
 
     let effect = effects.add(
-        EffectAsset::new(vec![32768], spawner, writer.finish())
+        EffectAsset::new(32768, spawner, writer.finish())
             .with_name("spawn_on_command")
             .init(init_pos)
             .init(init_vel)
@@ -155,14 +155,22 @@ fn setup(
 
 fn update(
     mut balls: Query<(&mut Ball, &mut Transform)>,
-    mut effect: Query<(&mut EffectProperties, &mut EffectSpawner, &mut Transform), Without<Ball>>,
+    mut effect: Query<
+        (
+            &mut EffectProperties,
+            &mut EffectInitializers,
+            &mut Transform,
+        ),
+        Without<Ball>,
+    >,
     time: Res<Time>,
 ) {
     const HALF_SIZE: f32 = BOX_SIZE / 2.0 - BALL_RADIUS;
 
     // Note: On first frame where the effect spawns, EffectSpawner is spawned during
     // PostUpdate, so will not be available yet. Ignore for a frame if so.
-    let Ok((mut properties, mut spawner, mut effect_transform)) = effect.get_single_mut() else {
+    let Ok((mut properties, mut initializers, mut effect_transform)) = effect.get_single_mut()
+    else {
         return;
     };
 
@@ -210,7 +218,7 @@ fn update(
             properties.set("normal", normal.extend(0.).into());
 
             // Spawn the particles
-            spawner.reset();
+            initializers.reset();
         }
     }
 }
diff --git a/examples/visibility.rs b/examples/visibility.rs
index b421b341..45752417 100644
--- a/examples/visibility.rs
+++ b/examples/visibility.rs
@@ -83,7 +83,7 @@ fn setup(
     };
 
     let mut asset = EffectAsset::new(
-        vec![4096],
+        4096,
         Spawner::burst(50.0.into(), 15.0.into()),
         writer.finish(),
     )
diff --git a/examples/worms.rs b/examples/worms.rs
index 6c95b8f2..6c4c7b10 100644
--- a/examples/worms.rs
+++ b/examples/worms.rs
@@ -77,9 +77,6 @@ fn setup(
 
     // Update modifiers
 
-    // Clone the particle every so often. This creates the trail.
-    let clone_modifier = CloneModifier::new(1.0 / 8.0, 1);
-
     // Make the particle wiggle, following a sine wave.
     let main_set_velocity_modifier = SetAttributeModifier::new(
         Attribute::VELOCITY,
@@ -95,9 +92,6 @@ fn setup(
     let trail_set_velocity_modifier =
         SetAttributeModifier::new(Attribute::VELOCITY, writer.lit(Vec3::ZERO).expr());
 
-    let trail_set_lifetime_modifier =
-        SetAttributeModifier::new(Attribute::LIFETIME, writer.lit(1.0).expr());
-
     // Render modifiers
 
     // Set the particle size.
@@ -120,24 +114,19 @@ fn setup(
     // Allocate room for 32,768 trail particles. Give each particle a 5-particle
     // trail, and spawn a new trail particle every ⅛ of a second.
     let effect = effects.add(
-        EffectAsset::new(
-            vec![5000, 5000 * 5],
-            Spawner::rate(CpuValue::Single(5.0)),
-            module,
-        )
-        .with_name("worms")
-        .init(set_initial_position_modifier)
-        .init(set_initial_angle_modifier)
-        .init(set_age_modifier)
-        .init(set_lifetime_modifier)
-        .init(set_color_modifier)
-        .update_groups(clone_modifier, ParticleGroupSet::single(0))
-        .update_groups(main_set_velocity_modifier, ParticleGroupSet::single(0))
-        .update_groups(trail_set_velocity_modifier, ParticleGroupSet::single(1))
-        .update_groups(trail_set_lifetime_modifier, ParticleGroupSet::single(1))
-        .render_groups(main_set_size_modifier, ParticleGroupSet::single(0))
-        .render_groups(trail_set_size_modifier, ParticleGroupSet::single(1))
-        .render(particle_texture_modifier),
+        EffectAsset::new(5000, Spawner::rate(CpuValue::Single(5.0)), module)
+            .with_trails(5000 * 5, 1.0 / 8.0, 1.0, 0)
+            .with_name("worms")
+            .init(set_initial_position_modifier)
+            .init(set_initial_angle_modifier)
+            .init(set_age_modifier)
+            .init(set_lifetime_modifier)
+            .init(set_color_modifier)
+            .update_groups(main_set_velocity_modifier, ParticleGroupSet::single(0))
+            .update_groups(trail_set_velocity_modifier, ParticleGroupSet::single(1))
+            .render_groups(main_set_size_modifier, ParticleGroupSet::single(0))
+            .render_groups(trail_set_size_modifier, ParticleGroupSet::single(1))
+            .render(particle_texture_modifier),
     );
 
     commands.spawn((
diff --git a/src/asset.rs b/src/asset.rs
index f02f3ca8..20edb46a 100644
--- a/src/asset.rs
+++ b/src/asset.rs
@@ -15,8 +15,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     modifier::{Modifier, RenderModifier},
-    ExprHandle, GroupedModifier, ModifierContext, Module, ParticleGroupSet, ParticleLayout,
-    Property, PropertyLayout, SimulationSpace, Spawner, TextureLayout,
+    spawn::{Cloner, Initializer},
+    Attribute, CpuValue, ExprHandle, GroupedModifier, ModifierContext, Module, ParticleGroupSet,
+    ParticleLayout, Property, PropertyLayout, SimulationSpace, Spawner, TextureLayout,
 };
 
 /// Type of motion integration applied to the particles of a system.
@@ -225,8 +226,10 @@ pub struct EffectAsset {
     /// should keep this quantity as close as possible to the maximum number of
     /// particles they expect to render.
     capacities: Vec<u32>,
-    /// Spawner.
-    pub spawner: Spawner,
+    /// The initializer for each group.
+    ///
+    /// Each initializer contains either a spawner or a cloner.
+    pub init: Vec<Initializer>,
     /// For 2D rendering, the Z coordinate used as the sort key.
     ///
     /// This value is passed to the render pipeline and used when sorting
@@ -258,6 +261,11 @@ pub struct EffectAsset {
     module: Module,
     /// Alpha mode.
     pub alpha_mode: AlphaMode,
+    /// Which group is to render as ribbons.
+    ///
+    /// There can be only one such group, because there's only one set of
+    /// next/previous pointers.
+    pub ribbon_group: Option<usize>,
 }
 
 impl EffectAsset {
@@ -274,9 +282,9 @@ impl EffectAsset {
     ///   store that many particles for as long as the effect exists. The
     ///   capacities of an effect are immutable. See also [`capacities()`] for
     ///   more details.
-    /// - The [`Spawner`], which defines when particles are emitted. All
-    ///   spawners spawn particles into group 0. (To add particles to other
-    ///   groups, use the [`crate::modifier::clone::CloneModifier`].)
+    /// - The [`Initializer`], which defines when particles are emitted.
+    ///   Initializers can be either spawners, to spawn new particles, or cloners,
+    ///   to clone particles from one group into another.
     ///
     /// Additionally, if any modifier added to this effect uses some [`Expr`] to
     /// customize its behavior, then those [`Expr`] are stored into a [`Module`]
@@ -292,7 +300,7 @@ impl EffectAsset {
     /// # use bevy_hanabi::*;
     /// let spawner = Spawner::rate(5_f32.into()); // 5 particles per second
     /// let module = Module::default();
-    /// let effect = EffectAsset::new(vec![32768], spawner, module);
+    /// let effect = EffectAsset::new(32768, spawner, module);
     /// ```
     ///
     /// Create a new effect asset with a modifier holding an expression. The
@@ -309,20 +317,36 @@ impl EffectAsset {
     /// let lifetime = module.lit(10.); // literal value "10.0"
     /// let init_lifetime = SetAttributeModifier::new(Attribute::LIFETIME, lifetime);
     ///
-    /// let effect = EffectAsset::new(vec![32768], spawner, module);
+    /// let effect = EffectAsset::new(32768, spawner, module);
     /// ```
     ///
     /// [`capacities()`]: crate::EffectAsset::capacities
     /// [`Expr`]: crate::graph::expr::Expr
-    pub fn new(capacities: Vec<u32>, spawner: Spawner, module: Module) -> Self {
+    pub fn new(capacity: u32, spawner: Spawner, module: Module) -> Self {
         Self {
-            capacities,
-            spawner,
+            capacities: vec![capacity],
+            init: vec![spawner.into()],
             module,
             ..default()
         }
     }
 
+    /// Creates a new particle group with the given capacity and initializer.
+    ///
+    /// Initializers can be spawners or cloners. Particle group indices are
+    /// assigned sequentially; thus, the first time you call this function (or
+    /// one of the convenience functions like [`Self::with_trails`] or
+    /// [`Self::with_ribbons`]), the ID of the resulting group will be 1, the
+    /// second time will create a group with ID 2, and so forth.
+    ///
+    /// For a less verbose way to create trails and ribbons, see
+    /// [`Self::with_trails`] and [`Self::with_ribbons`] respectively.
+    pub fn with_group(mut self, capacity: u32, initializer: impl Into<Initializer>) -> Self {
+        self.capacities.push(capacity);
+        self.init.push(initializer.into());
+        self
+    }
+
     /// Get the capacities of the effect, in number of particles per group.
     ///
     /// For example, if this function returns `&[256, 512]`, then this effect
@@ -380,6 +404,83 @@ impl EffectAsset {
         self
     }
 
+    /// Adds a new particle group that clones particles at an interval to
+    /// produce a trail.
+    ///
+    /// Trails allow your particles to emit copies of themselves at fixed
+    /// intervals, creating the effect of particles that follow one another.
+    /// Trails consist of particles that are disconnected from one another; to
+    /// visually connect the trail particles together, use a
+    /// [ribbon](Self::with_ribbons) instead.
+    ///
+    /// You may have as many trails as you wish per particle effect, up to the
+    /// limit on the number of groups.
+    ///
+    /// Particle group indices are assigned sequentially. The first group,
+    /// automatically created when you create an effect, has ID 0. Additional
+    /// groups, which functions like this one create, are assigned ID 1, 2, 3,
+    /// etc.
+    ///
+    /// `capacity` represents the maximum number of particles in the group.
+    /// `period` represents the fixed interval between clone operations.
+    /// `lifetime` represents how long each particle in the trail lives;
+    /// currently, it must be a fixed number of seconds. `src_group_index` is
+    /// the group from which the particles are to be cloned; most of the time,
+    /// you will want to pass 0 here to target the first group.
+    pub fn with_trails(
+        mut self,
+        capacity: u32,
+        period: impl Into<CpuValue<f32>>,
+        lifetime: f32,
+        src_group_index: u32,
+    ) -> Self {
+        self.capacities.push(capacity);
+        self.init.push(Initializer::Cloner(Cloner {
+            src_group_index,
+            period: period.into(),
+            lifetime,
+            starts_active: true,
+        }));
+        self
+    }
+
+    /// Adds a new particle group that creates a ribbon following particles from
+    /// another group.
+    ///
+    /// A ribbon is a connected string of quads that trail behind particles
+    /// from the source group. Hanabi emits new quads on a fixed interval given
+    /// by `period`. Ribbons are similar to [trails](Self::with_trails), but
+    /// while trail particles are disconnected, ribbon particles are connected.
+    ///
+    /// Because ribbons internally use a doubly-linked list, of which there's at
+    /// most one per effect, you may have at most one ribbon per particle
+    /// effect.
+    ///
+    /// Particle group indices are assigned sequentially. The first group,
+    /// automatically created when you create an effect, has ID 0. Additional
+    /// groups, which functions like this one create, are assigned ID 1, 2, 3,
+    /// etc.
+    ///
+    /// `capacity` represents the maximum number of ribbon segments in the
+    /// group. `period` represents the amount of time that Hanabi will wait
+    /// before spawning a new ribbon segment. `lifetime` represents the number
+    /// of seconds that each ribbon segment will persist for.
+    /// `src_group_index` is the group containing the particles that the ribbon
+    /// segments will follow; most of the time, you will want to pass 0 here to
+    /// target the first group.
+    pub fn with_ribbons(
+        mut self,
+        capacity: u32,
+        period: impl Into<CpuValue<f32>>,
+        lifetime: f32,
+        src_group_index: u32,
+    ) -> Self {
+        debug_assert!(self.ribbon_group.is_none());
+        self.ribbon_group = Some(self.capacities.len());
+        let period: CpuValue<f32> = period.into();
+        self.with_trails(capacity, period, lifetime, src_group_index)
+    }
+
     /// Get the list of existing properties.
     ///
     /// This is a shortcut for `self.module().properties()`.
@@ -389,9 +490,8 @@ impl EffectAsset {
 
     /// Add an initialization modifier to the effect.
     ///
-    /// Initialization modifiers only apply to particles that are freshly
-    /// spawned. Currently, spawners can only spawn into group 0. Consequently,
-    /// the initialization modifiers will only affect particles in group 0.
+    /// Initialization modifiers apply to all particles that are spawned or
+    /// cloned.
     ///
     /// # Panics
     ///
@@ -406,7 +506,28 @@ impl EffectAsset {
         assert!(modifier.context().contains(ModifierContext::Init));
         self.init_modifiers.push(GroupedModifier {
             modifier: Box::new(modifier),
-            groups: ParticleGroupSet::single(0),
+            groups: ParticleGroupSet::all(),
+        });
+        self
+    }
+
+    /// Add an initialization modifier to a specific set of groups.
+    ///
+    /// Initialization modifiers apply to all particles within those groups that
+    /// are spawned or cloned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the modifier doesn't support the init context (that is,
+    /// `modifier.context()` returns a flag which doesn't include
+    /// [`ModifierContext::Init`]).
+    pub fn init_groups<M>(mut self, modifier: M, groups: ParticleGroupSet) -> Self
+    where
+        M: Modifier + Send + Sync,
+    {
+        self.init_modifiers.push(GroupedModifier {
+            modifier: Box::new(modifier),
+            groups,
         });
         self
     }
@@ -611,6 +732,28 @@ impl EffectAsset {
         })
     }
 
+    /// Get a list of all the init modifiers in a single group.
+    ///
+    /// This is a filtered list of all modifiers, retaining only modifiers
+    /// executing in the [`ModifierContext::Init`] context and affecting the
+    /// specified group.
+    ///
+    /// [`ModifierContext::Init`]: crate::ModifierContext::Init
+    pub fn init_modifiers_for_group(
+        &self,
+        group_index: u32,
+    ) -> impl Iterator<Item = &dyn Modifier> {
+        self.init_modifiers.iter().filter_map(move |gm| {
+            if gm.groups.contains(group_index)
+                && gm.modifier.context().contains(ModifierContext::Init)
+            {
+                Some(gm.modifier.deref())
+            } else {
+                None
+            }
+        })
+    }
+
     /// Get a list of all the update modifiers of this effect.
     ///
     /// This is a filtered list of all modifiers, retaining only modifiers
@@ -694,6 +837,12 @@ impl EffectAsset {
             }
         }
 
+        // If we're using ribbons, we need a linked list.
+        if self.ribbon_group.is_some() {
+            set.insert(Attribute::PREV);
+            set.insert(Attribute::NEXT);
+        }
+
         // Build the layout
         let mut layout = ParticleLayout::new();
         for attr in set {
@@ -762,6 +911,12 @@ impl AssetLoader for EffectAssetLoader {
     }
 }
 
+#[derive(Debug, Default, Clone, Copy, PartialEq, Reflect)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ParticleTrails {
+    pub spawn_period: f32,
+}
+
 #[cfg(test)]
 mod tests {
     #[cfg(feature = "serde")]
@@ -813,7 +968,7 @@ mod tests {
             speed: module.lit(1.),
         };
 
-        let mut effect = EffectAsset::new(vec![4096], Spawner::rate(30.0.into()), module)
+        let mut effect = EffectAsset::new(4096, Spawner::rate(30.0.into()), module)
             .init(init_pos_sphere)
             .init(init_vel_sphere)
             //.update(AccelModifier::default())
@@ -896,7 +1051,7 @@ mod tests {
         let effect = EffectAsset {
             name: "Effect".into(),
             capacities: vec![4096],
-            spawner: Spawner::rate(30.0.into()),
+            init: vec![Spawner::rate(30.0.into()).into()],
             module,
             ..Default::default()
         }
@@ -912,13 +1067,15 @@ mod tests {
     capacities: [
         4096,
     ],
-    spawner: (
-        num_particles: Single(30.0),
-        spawn_time: Single(1.0),
-        period: Single(1.0),
-        starts_active: true,
-        starts_immediately: true,
-    ),
+    init: [
+        Spawner((
+            num_particles: Single(30.0),
+            spawn_time: Single(1.0),
+            period: Single(1.0),
+            starts_active: true,
+            starts_immediately: true,
+        )),
+    ],
     z_layer_2d: 0.0,
     simulation_space: Global,
     simulation_condition: WhenVisible,
@@ -962,12 +1119,13 @@ mod tests {
         ),
     ),
     alpha_mode: Blend,
+    ribbon_group: None,
 )"#
         );
         let effect_serde: EffectAsset = ron::from_str(&s).unwrap();
         assert_eq!(effect.name, effect_serde.name);
         assert_eq!(effect.capacities, effect_serde.capacities);
-        assert_eq!(effect.spawner, effect_serde.spawner);
+        assert_eq!(effect.init, effect_serde.init);
         assert_eq!(effect.z_layer_2d, effect_serde.z_layer_2d);
         assert_eq!(effect.simulation_space, effect_serde.simulation_space);
         assert_eq!(
diff --git a/src/attributes.rs b/src/attributes.rs
index 043c5c66..6359c8c1 100644
--- a/src/attributes.rs
+++ b/src/attributes.rs
@@ -974,6 +974,9 @@ impl Attribute {
 
     /// The previous particle in the ribbon chain.
     ///
+    /// This is only present if there's a ribbon. Since there's only one linked
+    /// list, we support at most one ribbon per effect.
+    ///
     /// # Name
     ///
     /// `prev`
@@ -986,6 +989,9 @@ impl Attribute {
 
     /// The next particle in the ribbon chain.
     ///
+    /// This is only present if there's a ribbon. Since there's only one linked
+    /// list, we support at most one ribbon per effect.
+    ///
     /// # Name
     ///
     /// `next`
diff --git a/src/graph/expr.rs b/src/graph/expr.rs
index 63e0af3e..81c98c2c 100644
--- a/src/graph/expr.rs
+++ b/src/graph/expr.rs
@@ -2117,7 +2117,7 @@ impl ToWgslString for TernaryOperator {
 ///
 /// // Create an EffectAsset with the modifier and the Module from the writer
 /// let effect =
-///     EffectAsset::new(vec![1024], Spawner::rate(32_f32.into()), w.finish()).init(init_modifier);
+///     EffectAsset::new(1024, Spawner::rate(32_f32.into()), w.finish()).init(init_modifier);
 /// ```
 ///
 /// [`finish()`]: ExprWriter::finish
@@ -2306,7 +2306,7 @@ impl ExprWriter {
     /// let mut w = ExprWriter::new();
     /// // [...]
     /// let module = w.finish();
-    /// let asset = EffectAsset::new(vec![256], spawner, module);
+    /// let asset = EffectAsset::new(256, spawner, module);
     /// ```
     ///
     /// [`EffectAsset::new()`]: crate::EffectAsset::new()
diff --git a/src/lib.rs b/src/lib.rs
index 1796342d..1e713080 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -99,7 +99,7 @@
 //!     // Create the effect asset
 //!     let effect = EffectAsset::new(
 //!         // Maximum number of particles alive at a time
-//!         vec![32768],
+//!         32768,
 //!         // Spawn at a rate of 5 particles per second
 //!         Spawner::rate(5.0.into()),
 //!         // Move the expression module into the asset
@@ -170,6 +170,7 @@ use std::fmt::Write as _;
 use bevy::math::FloatOrd;
 use bevy::{prelude::*, utils::HashSet};
 use serde::{Deserialize, Serialize};
+use spawn::Initializer;
 use thiserror::Error;
 
 mod asset;
@@ -196,7 +197,10 @@ pub use modifier::*;
 pub use plugin::{EffectSystems, HanabiPlugin};
 pub use properties::*;
 pub use render::{LayoutFlags, ShaderCache};
-pub use spawn::{tick_spawners, CpuValue, EffectSpawner, Random, Spawner};
+pub use spawn::{
+    tick_spawners, Cloner, CpuValue, EffectCloner, EffectInitializer, EffectInitializers,
+    EffectSpawner, Random, Spawner,
+};
 pub use time::{EffectSimulation, EffectSimulationTime};
 
 #[allow(missing_docs)]
@@ -705,8 +709,8 @@ pub struct TextureLayout {
 #[derive(Debug, Default, Clone)]
 pub(crate) struct EffectShader {
     pub init: Handle<Shader>,
-    pub update: Vec<Handle<Shader>>,
-    pub render: Vec<Handle<Shader>>,
+    pub update: Handle<Shader>,
+    pub render: Handle<Shader>,
 }
 
 /// Source code (WGSL) of an effect.
@@ -717,12 +721,17 @@ pub(crate) struct EffectShader {
 /// specialized (the conditional directives like `#if` are still present).
 #[derive(Debug)]
 struct EffectShaderSource {
-    pub init: String,
-    pub update: Vec<String>,
-    pub render: Vec<String>,
+    pub shaders: Vec<EffectGroupShaderSource>,
     pub layout_flags: LayoutFlags,
 }
 
+#[derive(Debug)]
+struct EffectGroupShaderSource {
+    init: String,
+    update: String,
+    render: String,
+}
+
 /// Error resulting from the generating of the WGSL shader code of an
 /// [`EffectAsset`].
 #[derive(Debug, Error)]
@@ -852,55 +861,6 @@ impl EffectShaderSource {
         // modifiers to the contexts.
         let mut module = asset.module().clone();
 
-        // Generate the shader code for the initializing shader
-        let (init_code, init_extra, init_sim_space_transform_code) = {
-            let mut init_context =
-                ShaderWriter::new(ModifierContext::Init, &property_layout, &particle_layout);
-            for m in asset.init_modifiers() {
-                if let Err(err) = m.apply(&mut module, &mut init_context) {
-                    error!("Failed to compile effect, error in init context: {:?}", err);
-                    return Err(ShaderGenerateError::Expr(err));
-                }
-            }
-
-            // If there are linked list attributes, clear them out.
-            // Not doing this is always a bug, so we might as well save the user
-            // some trouble.
-            for attribute in [Attribute::PREV, Attribute::NEXT] {
-                if particle_layout.contains(attribute) {
-                    init_context
-                        .main_code
-                        .push_str(&format!("particle.{} = 0xffffffffu;", attribute.name()));
-                }
-            }
-
-            let sim_space_transform_code =
-                asset.simulation_space.eval(&init_context).map_err(|err| {
-                    error!("Failed to compile effect's simulation space: {:?}", err);
-                    ShaderGenerateError::Expr(err)
-                })?;
-
-            (
-                init_context.main_code,
-                init_context.extra_code,
-                sim_space_transform_code,
-            )
-        };
-
-        // Configure the init shader template, and make sure a corresponding shader
-        // asset exists
-        let init_shader_source = PARTICLES_INIT_SHADER_TEMPLATE
-            .replace("{{ATTRIBUTES}}", &attributes_code)
-            .replace("{{INIT_CODE}}", &init_code)
-            .replace("{{INIT_EXTRA}}", &init_extra)
-            .replace("{{PROPERTIES}}", &properties_code)
-            .replace("{{PROPERTIES_BINDING}}", &properties_binding_code)
-            .replace(
-                "{{SIMULATION_SPACE_TRANSFORM_PARTICLE}}",
-                &init_sim_space_transform_code,
-            );
-        trace!("Configured init shader:\n{}", init_shader_source);
-
         let mut layout_flags = LayoutFlags::NONE;
         if asset.simulation_space == SimulationSpace::Local {
             layout_flags |= LayoutFlags::LOCAL_SPACE_SIMULATION;
@@ -908,14 +868,62 @@ impl EffectShaderSource {
         if let AlphaMode::Mask(_) = &asset.alpha_mode {
             layout_flags |= LayoutFlags::USE_ALPHA_MASK;
         }
+        if asset.ribbon_group.is_some() {
+            layout_flags |= LayoutFlags::RIBBONS;
+        }
+
+        let mut group_shader_sources = vec![];
+
+        // Configure the init shader template, and make sure a corresponding shader
+        // asset exists
+        for dest_group_index in 0..(asset.init.len() as u32) {
+            // Generate the shader code for the initializing shader
+            let (init_code, init_extra, init_sim_space_transform_code) = {
+                let mut init_context =
+                    ShaderWriter::new(ModifierContext::Init, &property_layout, &particle_layout);
+                for m in asset.init_modifiers_for_group(dest_group_index) {
+                    if let Err(err) = m.apply(&mut module, &mut init_context) {
+                        error!("Failed to compile effect, error in init context: {:?}", err);
+                        return Err(ShaderGenerateError::Expr(err));
+                    }
+                }
+
+                let sim_space_transform_code =
+                    asset.simulation_space.eval(&init_context).map_err(|err| {
+                        error!("Failed to compile effect's simulation space: {:?}", err);
+                        ShaderGenerateError::Expr(err)
+                    })?;
+
+                (
+                    init_context.main_code,
+                    init_context.extra_code,
+                    sim_space_transform_code,
+                )
+            };
+
+            let src_group_index = match asset.init[dest_group_index as usize] {
+                Initializer::Spawner(_) => 0,
+                Initializer::Cloner(cloner) => cloner.src_group_index,
+            };
+
+            let init_shader_source = PARTICLES_INIT_SHADER_TEMPLATE
+                .replace("{{ATTRIBUTES}}", &attributes_code)
+                .replace("{{INIT_CODE}}", &init_code)
+                .replace("{{INIT_EXTRA}}", &init_extra)
+                .replace("{{PROPERTIES}}", &properties_code)
+                .replace("{{PROPERTIES_BINDING}}", &properties_binding_code)
+                .replace("{{SRC_GROUP_INDEX}}", &src_group_index.to_string())
+                .replace("{{DEST_GROUP_INDEX}}", &dest_group_index.to_string())
+                .replace(
+                    "{{SIMULATION_SPACE_TRANSFORM_PARTICLE}}",
+                    &init_sim_space_transform_code,
+                );
 
-        let (mut update_shader_sources, mut render_shader_sources) = (vec![], vec![]);
-        for group_index in 0..(asset.capacities().len() as u32) {
             // Generate the shader code for the update shader
             let (mut update_code, update_extra) = {
                 let mut update_context =
                     ShaderWriter::new(ModifierContext::Update, &property_layout, &particle_layout);
-                for m in asset.update_modifiers_for_group(group_index) {
+                for m in asset.update_modifiers_for_group(dest_group_index) {
                     if let Err(err) = m.apply(&mut module, &mut update_context) {
                         error!(
                             "Failed to compile effect, error in update context: {:?}",
@@ -969,7 +977,7 @@ impl EffectShaderSource {
                 let texture_layout = module.texture_layout();
                 let mut render_context =
                     RenderContext::new(&property_layout, &particle_layout, &texture_layout);
-                for m in asset.render_modifiers_for_group(group_index) {
+                for m in asset.render_modifiers_for_group(dest_group_index) {
                     m.apply_render(&mut module, &mut render_context)
                         .map_err(ShaderGenerateError::Expr)?;
                 }
@@ -1070,7 +1078,23 @@ impl EffectShaderSource {
                 "".to_string()
             };
 
-            let group_index_code = format!("{}", group_index);
+            // Assign attributes individually instead of using struct
+            // assignment. Otherwise we might race on `PREV` and `NEXT`
+            // attributes, which might be updated behind our back when adjacent
+            // particles die.
+            let mut writeback_code = "".to_owned();
+            for attribute in present_attributes.iter().filter(|attribute| {
+                **attribute != Attribute::PREV && **attribute != Attribute::NEXT
+            }) {
+                writeln!(
+                    &mut writeback_code,
+                    "    particle_buffer.particles[index].{0} = particle.{0};",
+                    attribute.name()
+                )
+                .unwrap();
+            }
+
+            let dest_group_index_code = format!("{}", dest_group_index);
 
             // Configure the update shader template, and make sure a corresponding shader
             // asset exists
@@ -1079,10 +1103,11 @@ impl EffectShaderSource {
                 .replace("{{AGE_CODE}}", &age_code)
                 .replace("{{REAP_CODE}}", &reap_code)
                 .replace("{{UPDATE_CODE}}", &update_code)
+                .replace("{{WRITEBACK_CODE}}", &writeback_code)
                 .replace("{{UPDATE_EXTRA}}", &update_extra)
                 .replace("{{PROPERTIES}}", &properties_code)
                 .replace("{{PROPERTIES_BINDING}}", &properties_binding_code)
-                .replace("{{GROUP_INDEX}}", &group_index_code);
+                .replace("{{GROUP_INDEX}}", &dest_group_index_code);
             trace!("Configured update shader:\n{}", update_shader_source);
 
             // Configure the render shader template, and make sure a corresponding shader
@@ -1099,14 +1124,15 @@ impl EffectShaderSource {
                 .replace("{{FLIPBOOK_ROW_COUNT}}", &flipbook_row_count_code);
             trace!("Configured render shader:\n{}", render_shader_source);
 
-            update_shader_sources.push(update_shader_source);
-            render_shader_sources.push(render_shader_source);
+            group_shader_sources.push(EffectGroupShaderSource {
+                init: init_shader_source,
+                update: update_shader_source,
+                render: render_shader_source,
+            });
         }
 
         Ok(EffectShaderSource {
-            init: init_shader_source,
-            update: update_shader_sources,
-            render: render_shader_sources,
+            shaders: group_shader_sources,
             layout_flags,
         })
     }
@@ -1133,8 +1159,9 @@ pub struct CompiledParticleEffect {
     /// Cached simulation condition, to avoid having to query the asset each
     /// time we need it.
     simulation_condition: SimulationCondition,
-    /// Handle to the effect shader for his effect instance, if configured.
-    effect_shader: Option<EffectShader>,
+    /// Handle to the effect shaders for his effect instance (one per group), if
+    /// configured.
+    effect_shaders: Vec<EffectShader>,
     /// Textures used by the effect, if any.
     textures: Vec<Handle<Image>>,
     /// 2D layer for the effect instance.
@@ -1151,7 +1178,7 @@ impl Default for CompiledParticleEffect {
         Self {
             asset: default(),
             simulation_condition: SimulationCondition::default(),
-            effect_shader: None,
+            effect_shaders: vec![],
             textures: vec![],
             #[cfg(feature = "2d")]
             z_layer_2d: FloatOrd(0.0),
@@ -1165,7 +1192,7 @@ impl CompiledParticleEffect {
     /// Clear the compiled data from this component.
     pub(crate) fn clear(&mut self) {
         self.asset = Handle::default();
-        self.effect_shader = None;
+        self.effect_shaders.clear();
         self.textures.clear();
     }
 
@@ -1207,7 +1234,7 @@ impl CompiledParticleEffect {
             // Clear the compiled effect if the effect instance changed. We could try to get
             // smarter here, only invalidate what changed, but for now just wipe everything
             // and rebuild from scratch all three shaders together.
-            self.effect_shader = None;
+            self.effect_shaders.clear();
 
             // Update the 2D layer
             #[cfg(feature = "2d")]
@@ -1217,7 +1244,7 @@ impl CompiledParticleEffect {
         }
 
         // If the shaders are already compiled, there's nothing more to do
-        if self.effect_shader.is_some() {
+        if !self.effect_shaders.is_empty() {
             return;
         }
 
@@ -1235,27 +1262,6 @@ impl CompiledParticleEffect {
         self.layout_flags = shader_source.layout_flags;
         self.alpha_mode = asset.alpha_mode;
 
-        let init_shader = shader_cache.get_or_insert(&asset.name, &shader_source.init, shaders);
-        let update_shaders: Vec<_> = shader_source
-            .update
-            .iter()
-            .map(|update_source| shader_cache.get_or_insert(&asset.name, update_source, shaders))
-            .collect();
-        let render_shaders: Vec<_> = shader_source
-            .render
-            .iter()
-            .map(|render_source| shader_cache.get_or_insert(&asset.name, render_source, shaders))
-            .collect();
-
-        trace!(
-            "CompiledParticleEffect::update(): init_shader={:?} update_shaders={:?} render_shaders={:?} texture_count={} layout_flags={:?}",
-            init_shader,
-            update_shaders,
-            render_shaders,
-            material.map(|mat| mat.images.len()).unwrap_or(0),
-            self.layout_flags,
-        );
-
         // TODO - Replace with Option<EffectShader { handle: Handle<Shader>, hash:
         // u64 }> where the hash takes into account the code and extra code
         // for each pass (and any other varying item). We don't need to keep
@@ -1263,18 +1269,46 @@ impl CompiledParticleEffect {
         // to avoid hash collisions, an index into a shader cache). The only
         // use is to be able to compare 2 instances and see if they can be
         // batched together.
-        self.effect_shader = Some(EffectShader {
-            init: init_shader,
-            update: update_shaders,
-            render: render_shaders,
-        });
+        self.effect_shaders = shader_source
+            .shaders
+            .iter()
+            .map(|effect_group_shader_source| {
+                let init = shader_cache.get_or_insert(
+                    &asset.name,
+                    &effect_group_shader_source.init,
+                    shaders,
+                );
+                let update = shader_cache.get_or_insert(
+                    &asset.name,
+                    &effect_group_shader_source.update,
+                    shaders,
+                );
+                let render = shader_cache.get_or_insert(
+                    &asset.name,
+                    &effect_group_shader_source.render,
+                    shaders,
+                );
+                EffectShader {
+                    init,
+                    update,
+                    render,
+                }
+            })
+            .collect();
+
+        trace!(
+            "CompiledParticleEffect::update(): shaders={:?} texture_count={} layout_flags={:?}",
+            self.effect_shaders,
+            material.map(|mat| mat.images.len()).unwrap_or(0),
+            self.layout_flags,
+        );
 
         self.textures = material.map(|mat| &mat.images).cloned().unwrap_or_default();
     }
 
     /// Get the effect shader if configured, or `None` otherwise.
-    pub(crate) fn get_configured_shader(&self) -> Option<EffectShader> {
-        self.effect_shader.clone()
+    pub(crate) fn get_configured_shaders(&self) -> &[EffectShader] {
+        &self.effect_shaders
     }
 }
 
@@ -1509,7 +1543,7 @@ fn gather_removed_effects(
 
 #[cfg(test)]
 mod tests {
-    use std::{iter, ops::DerefMut};
+    use std::ops::DerefMut;
 
     use bevy::{
         asset::{
@@ -1785,7 +1819,7 @@ else { return c1; }
     fn test_effect_shader_source() {
         // Empty particle layout
         let module = Module::default();
-        let asset = EffectAsset::new(vec![256], Spawner::rate(32.0.into()), module)
+        let asset = EffectAsset::new(256, Spawner::rate(32.0.into()), module)
             .with_simulation_space(SimulationSpace::Local);
         assert_eq!(asset.simulation_space, SimulationSpace::Local);
         let res = EffectShaderSource::generate(&asset);
@@ -1796,7 +1830,7 @@ else { return c1; }
         // Missing Attribute::POSITION, currently mandatory for all effects
         let mut module = Module::default();
         let zero = module.lit(Vec3::ZERO);
-        let asset = EffectAsset::new(vec![256], Spawner::rate(32.0.into()), module)
+        let asset = EffectAsset::new(256, Spawner::rate(32.0.into()), module)
             .init(SetAttributeModifier::new(Attribute::VELOCITY, zero));
         assert!(asset.particle_layout().size() > 0);
         let res = EffectShaderSource::generate(&asset);
@@ -1807,25 +1841,28 @@ else { return c1; }
         // Valid
         let mut module = Module::default();
         let zero = module.lit(Vec3::ZERO);
-        let asset = EffectAsset::new(vec![256], Spawner::rate(32.0.into()), module)
+        let asset = EffectAsset::new(256, Spawner::rate(32.0.into()), module)
             .with_simulation_space(SimulationSpace::Local)
             .init(SetAttributeModifier::new(Attribute::POSITION, zero));
         assert_eq!(asset.simulation_space, SimulationSpace::Local);
         let res = EffectShaderSource::generate(&asset);
         assert!(res.is_ok());
         let shader_source = res.unwrap();
-        for (name, code) in iter::once(("Init", &shader_source.init))
+        for (name, code) in shader_source
+            .shaders
+            .iter()
+            .map(|shader| ("Init", &*shader.init))
             .chain(
                 shader_source
-                    .update
+                    .shaders
                     .iter()
-                    .map(|update_source| ("Update", update_source)),
+                    .map(|shader| ("Update", &*shader.update)),
             )
             .chain(
                 shader_source
-                    .render
+                    .shaders
                     .iter()
-                    .map(|render_source| ("Render", render_source)),
+                    .map(|shader| ("Render", &*shader.render)),
             )
         {
             println!("{} shader:\n\n{}", name, code);
@@ -1945,7 +1982,7 @@ else { return c1; }
                 compiled_particle_effect.asset,
                 Handle::<EffectAsset>::default()
             );
-            assert!(compiled_particle_effect.effect_shader.is_none());
+            assert!(compiled_particle_effect.effect_shaders.is_empty());
         }
     }
 
@@ -1963,7 +2000,7 @@ else { return c1; }
             let mut assets = world.resource_mut::<Assets<EffectAsset>>();
             let mut module = Module::default();
             let init_pos = module.lit(Vec3::ZERO);
-            let mut asset = EffectAsset::new(vec![64], spawner, module)
+            let mut asset = EffectAsset::new(64, spawner, module)
                 .init(SetAttributeModifier::new(Attribute::POSITION, init_pos));
             asset.simulation_condition = SimulationCondition::Always;
             let handle = assets.add(asset);
@@ -2000,7 +2037,7 @@ else { return c1; }
             // `compile_effects()` always updates the CompiledParticleEffect
             assert_eq!(compiled_particle_effect.asset, handle);
             assert!(compiled_particle_effect.asset.is_strong());
-            assert!(compiled_particle_effect.effect_shader.is_some());
+            assert!(!compiled_particle_effect.effect_shaders.is_empty());
         }
 
         // Mark as changed without actually changing anything
@@ -2035,7 +2072,7 @@ else { return c1; }
             // `compile_effects()` always updates the CompiledParticleEffect
             assert_eq!(compiled_particle_effect.asset, handle);
             assert!(compiled_particle_effect.asset.is_strong());
-            assert!(compiled_particle_effect.effect_shader.is_some());
+            assert!(!compiled_particle_effect.effect_shaders.is_empty());
         }
     }
 
@@ -2057,7 +2094,7 @@ else { return c1; }
                 let mut assets = world.resource_mut::<Assets<EffectAsset>>();
                 let mut module = Module::default();
                 let init_pos = module.lit(Vec3::ZERO);
-                let mut asset = EffectAsset::new(vec![64], spawner, module)
+                let mut asset = EffectAsset::new(64, spawner, module)
                     .init(SetAttributeModifier::new(Attribute::POSITION, init_pos));
                 asset.simulation_condition = if test_case.visibility.is_some() {
                     SimulationCondition::WhenVisible
@@ -2132,7 +2169,7 @@ else { return c1; }
                 // even if hidden
                 assert_eq!(compiled_particle_effect.asset, handle);
                 assert!(compiled_particle_effect.asset.is_strong());
-                assert!(compiled_particle_effect.effect_shader.is_some());
+                assert!(!compiled_particle_effect.effect_shaders.is_empty());
 
                 // Toggle visibility and tick once more; this shouldn't panic (regression; #182)
                 let (mut visibility, _) = world
@@ -2160,7 +2197,7 @@ else { return c1; }
                 // `compile_effects()` always updates the CompiledParticleEffect
                 assert_eq!(compiled_particle_effect.asset, handle);
                 assert!(compiled_particle_effect.asset.is_strong());
-                assert!(compiled_particle_effect.effect_shader.is_some());
+                assert!(!compiled_particle_effect.effect_shaders.is_empty());
             }
         }
     }
diff --git a/src/modifier/clone.rs b/src/modifier/clone.rs
deleted file mode 100644
index 998b747f..00000000
--- a/src/modifier/clone.rs
+++ /dev/null
@@ -1,185 +0,0 @@
-//! Modifiers to duplicate particles.
-
-use std::hash::{Hash, Hasher};
-
-use bevy::{math::FloatOrd, prelude::*};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    calc_func_id, Attribute, BoxedModifier, EvalContext, ExprError, Modifier, ModifierContext,
-    Module, ShaderWriter,
-};
-
-/// Duplicates a particle and places it in a group.
-///
-/// Spawners always spawn particles into group 0, so this is the primary way to
-/// place particles into groups other than 0. Typical uses of this modifier are
-/// to create trails.
-///
-/// All attributes are copied to the new particle, with the exception of
-/// [`Attribute::AGE`], which is reset to zero.
-#[derive(Debug, Clone, Copy, PartialEq, Reflect, Serialize, Deserialize)]
-pub struct CloneModifier {
-    /// How many seconds must elapse before the particle will be duplicated.
-    ///
-    /// If this is zero, particles will be duplicated every frame.
-    pub spawn_period: f32,
-    /// The group that the new particle will be spawned into.
-    pub destination_group: u32,
-}
-
-#[cfg_attr(feature = "serde", typetag::serde)]
-impl Modifier for CloneModifier {
-    fn context(&self) -> ModifierContext {
-        ModifierContext::Update
-    }
-
-    fn attributes(&self) -> &[Attribute] {
-        &[]
-    }
-
-    fn boxed_clone(&self) -> BoxedModifier {
-        Box::new(*self)
-    }
-
-    fn apply(&self, module: &mut Module, context: &mut ShaderWriter) -> Result<(), ExprError> {
-        let func_id = calc_func_id(self);
-        let func_name = format!("duplicate_{0:016X}", func_id);
-        let multiple_count_name = format!("multiple_count_{0:016X}", func_id);
-
-        context.make_fn(
-            &func_name,
-            "particle: ptr<function, Particle>, orig_index: u32",
-            module,
-            &mut |_m: &mut Module, context: &mut dyn EvalContext| -> Result<String, ExprError> {
-                let age_reset_code = if context.particle_layout().contains(Attribute::AGE) {
-                    format!("new_particle.{} = 0.0;", Attribute::AGE.name())
-                } else {
-                    "".to_owned()
-                };
-
-                // If applicable, insert the particle into a linked list, either
-                // singly or doubly linked. This is typically used for ribbons.
-
-                let next_link_code = if context.particle_layout().contains(Attribute::NEXT) {
-                    format!("new_particle.{next} = orig_index;\n", next = Attribute::NEXT.name())
-                } else {
-                    "".to_owned()
-                };
-
-                let prev_link_code = if context.particle_layout().contains(Attribute::PREV) {
-                    format!(
-                        r##"
-                        new_particle.{prev} = (*particle).{prev};
-                        (*particle).{prev} = new_index;
-                        "##,
-                        prev = Attribute::PREV.name()
-                    )
-                } else {
-                    "".to_owned()
-                };
-
-                let double_link_code = if context.particle_layout().contains(Attribute::NEXT) &&
-                        context.particle_layout().contains(Attribute::PREV) {
-                    format!(
-                        r##"
-                        if (new_particle.{prev} < arrayLength(&particle_buffer.particles)) {{
-                            particle_buffer.particles[new_particle.{prev}].{next} = new_index;
-                        }}
-                        "##,
-                        next = Attribute::NEXT.name(),
-                        prev = Attribute::PREV.name()
-                    )
-                } else {
-                    "".to_owned()
-                };
-
-                Ok(format!(
-                    r##"
-                    let base_index = particle_groups[{dest}u].indirect_index;
-
-                    // Recycle a dead particle.
-                    let dead_index = atomicSub(&render_group_indirect[{dest}u].dead_count, 1u) - 1u;
-                    // HACK - we have no limiter for dead_count, so could go negative (wrap around).
-                    // Assume that any value above 2^31 is a wrap around, undo the atomic op and return.
-                    if (dead_index >= 0xF0000000) {{
-                        atomicAdd(&render_group_indirect[{dest}u].dead_count, 1u);
-                        return;
-                    }}
-                    let new_index = indirect_buffer.indices[3u * (base_index + dead_index) + 2u];
-
-                    // Initialize the new particle.
-                    var new_particle = *particle;
-                    {age_reset_code}
-
-                    // Insert the particle between us and our current `prev`
-                    // node, if applicable.
-                    {next_link_code}
-                    {prev_link_code}
-                    {double_link_code}
-
-                    // Copy the new particle into the buffer.
-                    particle_buffer.particles[new_index] = new_particle;
-
-                    // Mark it as alive.
-                    atomicAdd(&render_group_indirect[{dest}u].alive_count, 1u);
-
-                    // Add an instance.
-                    let ping = render_effect_indirect.ping;
-                    let indirect_index = atomicAdd(&render_group_indirect[{dest}u].instance_count, 1u);
-                    indirect_buffer.indices[3u * (base_index + indirect_index) + ping] = new_index;
-                "##,
-                    dest = self.destination_group,
-                ))
-            },
-        )?;
-
-        if self.spawn_period <= 0.0 {
-            context.main_code += &format!("{func}(&particle);", func = func_name);
-        } else {
-            // Calculate the number of multiples of `spawn_period` that fall
-            // between the last tick and this one, and spawn one particle for
-            // each such multiple.
-            //
-            // https://stackoverflow.com/a/31871205
-            context.main_code += &format!(
-                r##"
-                let {multiple_count} = max(0, i32(floor({b} / {m})) - i32(ceil(({b} - {delta}) / {m})) + 1);
-                for (var i = 0; i < {multiple_count}; i += 1) {{
-                    {func}(&particle, index);
-                }}
-            "##,
-                func = func_name,
-                multiple_count = multiple_count_name,
-                b = "sim_params.time",
-                delta = "sim_params.delta_time",
-                m = self.spawn_period
-            );
-        }
-
-        Ok(())
-    }
-}
-
-impl CloneModifier {
-    /// Creates a new [`CloneModifier`] that will duplicate particles every
-    /// `spawn_period` seconds into the `destination_group`.
-    pub fn new(spawn_period: f32, destination_group: u32) -> CloneModifier {
-        CloneModifier {
-            spawn_period,
-            destination_group,
-        }
-    }
-}
-
-impl Eq for CloneModifier {}
-
-impl Hash for CloneModifier {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        FloatOrd(self.spawn_period).hash(state);
-        self.destination_group.hash(state);
-    }
-}
diff --git a/src/modifier/mod.rs b/src/modifier/mod.rs
index b9d5ea52..b074104f 100644
--- a/src/modifier/mod.rs
+++ b/src/modifier/mod.rs
@@ -37,22 +37,18 @@ use serde::{Deserialize, Serialize};
 
 pub mod accel;
 pub mod attr;
-pub mod clone;
 pub mod force;
 pub mod kill;
 pub mod output;
 pub mod position;
-pub mod ribbon;
 pub mod velocity;
 
 pub use accel::*;
 pub use attr::*;
-pub use clone::*;
 pub use force::*;
 pub use kill::*;
 pub use output::*;
 pub use position::*;
-pub use ribbon::*;
 pub use velocity::*;
 
 use crate::{
diff --git a/src/modifier/output.rs b/src/modifier/output.rs
index badebc62..f48f0f4d 100644
--- a/src/modifier/output.rs
+++ b/src/modifier/output.rs
@@ -592,7 +592,7 @@ axis_z = cross(axis_x, axis_y);
 /// let texture_slot = writer.lit(0u32).expr();
 ///
 /// let asset = EffectAsset::new(
-///     vec![32768],
+///     32768,
 ///     Spawner::once(32.0.into(), true),
 ///     writer.finish(),
 /// )
diff --git a/src/modifier/ribbon.rs b/src/modifier/ribbon.rs
deleted file mode 100644
index 12f52725..00000000
--- a/src/modifier/ribbon.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-//! Renders particles as ribbons.
-
-use bevy::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    impl_mod_render, Attribute, EvalContext, ExprError, Modifier, ModifierContext, Module,
-    RenderContext, RenderModifier, ShaderWriter,
-};
-
-/// Renders particles as ribbons, drawing a quad in between each particle
-/// instead of at each particle.
-///
-/// Internally, this threads particles into a linked list, using the
-/// [`Attribute::PREV`] and [`Attribute::NEXT`] fields.
-#[derive(Debug, Clone, Copy, Reflect, Serialize, Deserialize)]
-pub struct RibbonModifier;
-
-impl_mod_render!(RibbonModifier, &[Attribute::PREV, Attribute::NEXT]);
-
-#[cfg_attr(feature = "serde", typetag::serde)]
-impl RenderModifier for RibbonModifier {
-    fn apply_render(&self, _: &mut Module, context: &mut RenderContext) -> Result<(), ExprError> {
-        context.vertex_code += r##"
-    let next_index = particle.next;
-    if (next_index >= arrayLength(&particle_buffer.particles)) {
-        out.position = vec4(0.0);
-        return out;
-    }
-
-    let next_particle = particle_buffer.particles[next_index];
-    var delta = next_particle.position - particle.position;
-
-    axis_x = normalize(delta);
-    axis_y = normalize(cross(axis_x, axis_z));
-    axis_z = cross(axis_x, axis_y);
-
-    position = mix(next_particle.position, particle.position, 0.5);
-    size = vec2(length(delta), size.y);
-"##;
-
-        Ok(())
-    }
-
-    fn boxed_render_clone(&self) -> Box<dyn RenderModifier> {
-        Box::new(*self)
-    }
-
-    fn as_modifier(&self) -> &dyn Modifier {
-        self
-    }
-}
diff --git a/src/plugin.rs b/src/plugin.rs
index f87ccda3..0740f1ef 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -272,6 +272,8 @@ impl Plugin for HanabiPlugin {
             .init_resource::<DispatchIndirectPipeline>()
             .init_resource::<ParticlesInitPipeline>()
             .init_resource::<SpecializedComputePipelines<ParticlesInitPipeline>>()
+            .init_resource::<ParticlesInitPipeline>()
+            .init_resource::<SpecializedComputePipelines<ParticlesInitPipeline>>()
             .init_resource::<ParticlesUpdatePipeline>()
             .init_resource::<SpecializedComputePipelines<ParticlesUpdatePipeline>>()
             .init_resource::<ParticlesRenderPipeline>()
diff --git a/src/render/batch.rs b/src/render/batch.rs
index 78625803..ce7c26be 100644
--- a/src/render/batch.rs
+++ b/src/render/batch.rs
@@ -11,7 +11,10 @@ use super::{
     effect_cache::{DispatchBufferIndices, EffectSlices},
     EffectCacheId, GpuCompressedTransform, LayoutFlags,
 };
-use crate::{AlphaMode, EffectAsset, EffectShader, ParticleLayout, PropertyLayout, TextureLayout};
+use crate::{
+    spawn::EffectInitializer, AlphaMode, EffectAsset, EffectShader, ParticleLayout, PropertyLayout,
+    TextureLayout,
+};
 
 /// Data needed to render all batches pertaining to a specific effect.
 #[derive(Debug, Component)]
@@ -24,8 +27,8 @@ pub(crate) struct EffectBatches {
     pub buffer_index: u32,
     /// Index of the first Spawner of the effects in the batch.
     pub spawner_base: u32,
-    /// Number of particles to spawn/init this frame.
-    pub spawn_count: u32,
+    /// The initializer (spawner or cloner) for each particle group.
+    pub initializers: Vec<EffectInitializer>,
     /// The effect cache ID.
     pub effect_cache_id: EffectCacheId,
     /// The indices within the various indirect dispatch buffers.
@@ -54,10 +57,8 @@ pub(crate) struct EffectBatches {
     /// Note that we don't need to keep the init/update shaders alive because
     /// their pipeline specialization is doing it via the specialization key.
     pub render_shaders: Vec<Handle<Shader>>,
-    /// Init compute pipeline specialized for this batch.
-    pub init_pipeline_id: CachedComputePipelineId,
-    /// Update compute pipeline specialized for this batch.
-    pub update_pipeline_ids: Vec<CachedComputePipelineId>,
+    /// Init and update compute pipelines specialized for this batch.
+    pub init_and_update_pipeline_ids: Vec<InitAndUpdatePipelineIds>,
 }
 
 impl Index<u32> for EffectBatches {
@@ -103,15 +104,14 @@ impl EffectBatches {
         input: BatchesInput,
         spawner_base: u32,
         effect_cache_id: EffectCacheId,
-        init_pipeline_id: CachedComputePipelineId,
-        update_pipeline_ids: Vec<CachedComputePipelineId>,
+        init_and_update_pipeline_ids: Vec<InitAndUpdatePipelineIds>,
         dispatch_buffer_indices: DispatchBufferIndices,
         first_particle_group_buffer_index: u32,
     ) -> EffectBatches {
         EffectBatches {
             buffer_index: input.effect_slices.buffer_index,
             spawner_base,
-            spawn_count: input.spawn_count,
+            initializers: input.initializers.clone(),
             particle_layout: input.effect_slices.particle_layout,
             effect_cache_id,
             dispatch_buffer_indices,
@@ -129,9 +129,12 @@ impl EffectBatches {
             texture_layout: input.texture_layout,
             textures: input.textures,
             alpha_mode: input.alpha_mode,
-            render_shaders: input.effect_shader.render,
-            init_pipeline_id,
-            update_pipeline_ids,
+            render_shaders: input
+                .effect_shaders
+                .iter()
+                .map(|shaders| shaders.render.clone())
+                .collect(),
+            init_and_update_pipeline_ids,
             entities: vec![input.entity.index()],
         }
     }
@@ -149,8 +152,8 @@ pub(crate) struct BatchesInput {
     pub effect_slices: EffectSlices,
     /// Layout of the effect properties.
     pub property_layout: PropertyLayout,
-    /// Effect shader.
-    pub effect_shader: EffectShader,
+    /// Effect shaders.
+    pub effect_shaders: Vec<EffectShader>,
     /// Various flags related to the effect.
     pub layout_flags: LayoutFlags,
     /// Texture layout.
@@ -159,8 +162,8 @@ pub(crate) struct BatchesInput {
     pub textures: Vec<Handle<Image>>,
     /// Alpha mode.
     pub alpha_mode: AlphaMode,
-    /// Number of particles to spawn for this effect.
-    pub spawn_count: u32,
+    pub particle_layout: ParticleLayout,
+    pub initializers: Vec<EffectInitializer>,
     /// Emitter transform.
     pub transform: GpuCompressedTransform,
     /// Emitter inverse transform.
@@ -174,3 +177,9 @@ pub(crate) struct BatchesInput {
     #[cfg(feature = "2d")]
     pub z_sort_key_2d: FloatOrd,
 }
+
+#[derive(Debug)]
+pub(crate) struct InitAndUpdatePipelineIds {
+    pub(crate) init: CachedComputePipelineId,
+    pub(crate) update: CachedComputePipelineId,
+}
diff --git a/src/render/buffer_table.rs b/src/render/buffer_table.rs
index e0116ad9..bf044a51 100644
--- a/src/render/buffer_table.rs
+++ b/src/render/buffer_table.rs
@@ -19,6 +19,13 @@ use crate::next_multiple_of;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct BufferTableId(pub(crate) u32); // TEMP: pub(crate)
 
+impl BufferTableId {
+    #[inline]
+    pub fn offset(&self, index: u32) -> BufferTableId {
+        BufferTableId(self.0 + index)
+    }
+}
+
 #[derive(Debug)]
 struct AllocatedBuffer {
     /// Currently allocated buffer, of size equal to `size`.
diff --git a/src/render/effect_cache.rs b/src/render/effect_cache.rs
index db1a9a6a..c22dd489 100644
--- a/src/render/effect_cache.rs
+++ b/src/render/effect_cache.rs
@@ -686,7 +686,7 @@ pub(crate) struct CachedEffectIndices {
 
 /// The indices in the indirect dispatch buffers for a single effect, as well as
 /// that of the metadata buffer.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub(crate) struct DispatchBufferIndices {
     /// The index of the first update group indirect dispatch buffer.
     ///
@@ -698,6 +698,13 @@ pub(crate) struct DispatchBufferIndices {
     pub(crate) first_render_group_dispatch_buffer_index: BufferTableId,
     /// The index of the render indirect metadata buffer.
     pub(crate) render_effect_metadata_buffer_index: BufferTableId,
+    pub(crate) trail_dispatch_buffer_indices: HashMap<u32, TrailDispatchBufferIndices>,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct TrailDispatchBufferIndices {
+    pub(crate) dest: BufferTableId,
+    pub(crate) src: BufferTableId,
 }
 
 impl Default for DispatchBufferIndices {
@@ -707,6 +714,7 @@ impl Default for DispatchBufferIndices {
             first_update_group_dispatch_buffer_index: BufferTableId(0),
             first_render_group_dispatch_buffer_index: BufferTableId(0),
             render_effect_metadata_buffer_index: BufferTableId(0),
+            trail_dispatch_buffer_indices: HashMap::default(),
         }
     }
 }
@@ -839,8 +847,8 @@ impl EffectCache {
             .unwrap()
     }
 
-    pub(crate) fn get_dispatch_buffer_indices(&self, id: EffectCacheId) -> DispatchBufferIndices {
-        self.effects[&id].slices.dispatch_buffer_indices
+    pub(crate) fn get_dispatch_buffer_indices(&self, id: EffectCacheId) -> &DispatchBufferIndices {
+        &self.effects[&id].slices.dispatch_buffer_indices
     }
 
     /// Get the init bind group for a cached effect.
diff --git a/src/render/mod.rs b/src/render/mod.rs
index 6c6c2240..686165d2 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -1,9 +1,10 @@
 use std::{
     borrow::Cow,
-    num::{NonZeroU32, NonZeroU64},
+    num::{NonZero, NonZeroU32, NonZeroU64},
 };
 use std::{iter, marker::PhantomData};
 
+use batch::InitAndUpdatePipelineIds;
 #[cfg(feature = "2d")]
 use bevy::core_pipeline::core_2d::Transparent2d;
 #[cfg(feature = "2d")]
@@ -43,6 +44,7 @@ use bevy::{
 };
 use bitflags::bitflags;
 use bytemuck::{Pod, Zeroable};
+use effect_cache::TrailDispatchBufferIndices;
 use fixedbitset::FixedBitSet;
 use naga_oil::compose::{Composer, NagaModuleDescriptor};
 use rand::random;
@@ -55,8 +57,8 @@ use crate::{
         batch::{BatchesInput, EffectDrawBatch},
         effect_cache::DispatchBufferIndices,
     },
-    spawn::EffectSpawner,
-    AlphaMode, CompiledParticleEffect, EffectProperties, EffectShader, EffectSimulation,
+    spawn::{EffectCloner, EffectInitializer, EffectInitializers, Initializer},
+    AlphaMode, Attribute, CompiledParticleEffect, EffectProperties, EffectShader, EffectSimulation,
     HanabiPlugin, ParticleLayout, PropertyLayout, RemovedEffectsEvent, SimulationCondition,
     TextureLayout, ToWgslString,
 };
@@ -274,6 +276,12 @@ pub(crate) struct GpuSpawnerParams {
     count: i32,
     /// Index of the effect in the indirect dispatch and render buffers.
     effect_index: u32,
+    /// The time in seconds that the cloned particles live, if this is a cloner.
+    ///
+    /// If this is a spawner, this value is zero.
+    lifetime: f32,
+    /// Padding.
+    pad: [u32; 3],
 }
 
 // FIXME - min_storage_buffer_offset_alignment
@@ -300,7 +308,6 @@ impl Default for GpuDispatchIndirect {
 #[repr(C)]
 #[derive(Debug, Default, Clone, Copy, Pod, Zeroable, ShaderType)]
 pub struct GpuRenderEffectMetadata {
-    pub max_spawn: u32,
     pub ping: u32,
 }
 
@@ -315,6 +322,7 @@ pub struct GpuRenderGroupIndirect {
     pub alive_count: u32,
     pub max_update: u32,
     pub dead_count: u32,
+    pub max_spawn: u32,
 }
 
 /// Stores metadata about each particle group.
@@ -415,6 +423,16 @@ impl FromWorld for DispatchIndirectPipeline {
                     },
                     count: None,
                 },
+                BindGroupLayoutEntry {
+                    binding: 4,
+                    visibility: ShaderStages::COMPUTE,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Storage { read_only: true },
+                        has_dynamic_offset: false,
+                        min_binding_size: Some(GpuSpawnerParams::min_size()),
+                    },
+                    count: None,
+                },
             ],
         );
 
@@ -518,25 +536,33 @@ impl FromWorld for DispatchIndirectPipeline {
 
 #[derive(Resource)]
 pub(crate) struct ParticlesInitPipeline {
-    /// Render device the pipeline is attached to.
     render_device: RenderDevice,
     sim_params_layout: BindGroupLayout,
     spawner_buffer_layout: BindGroupLayout,
     render_indirect_layout: BindGroupLayout,
 }
 
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) struct ParticleInitPipelineKey {
+    shader: Handle<Shader>,
+    particle_layout_min_binding_size: NonZero<u64>,
+    property_layout_min_binding_size: Option<NonZero<u64>>,
+    flags: ParticleInitPipelineKeyFlags,
+}
+
+bitflags! {
+    #[derive(Clone, Copy, PartialEq, Eq, Hash)]
+    pub struct ParticleInitPipelineKeyFlags: u8 {
+        const CLONE = 0x1;
+        const ATTRIBUTE_PREV = 0x2;
+        const ATTRIBUTE_NEXT = 0x4;
+    }
+}
+
 impl FromWorld for ParticlesInitPipeline {
     fn from_world(world: &mut World) -> Self {
         let render_device = world.get_resource::<RenderDevice>().unwrap();
 
-        let limits = render_device.limits();
-        bevy::log::info!(
-            "GPU limits:\n- max_compute_invocations_per_workgroup={}\n- max_compute_workgroup_size_x={}\n- max_compute_workgroup_size_y={}\n- max_compute_workgroup_size_z={}\n- max_compute_workgroups_per_dimension={}\n- min_storage_buffer_offset_alignment={}\n- max_storage_buffers_per_shader_stage={}\n- max_bind_groups={}",
-            limits.max_compute_invocations_per_workgroup, limits.max_compute_workgroup_size_x, limits.max_compute_workgroup_size_y, limits.max_compute_workgroup_size_z,
-            limits.max_compute_workgroups_per_dimension, limits.min_storage_buffer_offset_alignment, limits.max_storage_buffers_per_shader_stage, limits.max_bind_groups
-        );
-
-        trace!("GpuSimParams: min_size={}", GpuSimParams::min_size());
         let sim_params_layout = render_device.create_bind_group_layout(
             "hanabi:bind_group_layout:update_sim_params",
             &[BindGroupLayoutEntry {
@@ -551,10 +577,6 @@ impl FromWorld for ParticlesInitPipeline {
             }],
         );
 
-        trace!(
-            "GpuSpawnerParams: min_size={}",
-            GpuSpawnerParams::min_size()
-        );
         let spawner_buffer_layout = render_device.create_bind_group_layout(
             "hanabi:buffer_layout:init_spawner",
             &[BindGroupLayoutEntry {
@@ -569,43 +591,10 @@ impl FromWorld for ParticlesInitPipeline {
             }],
         );
 
-        let storage_alignment = render_device.limits().min_storage_buffer_offset_alignment;
-        let render_effect_indirect_size = GpuRenderEffectMetadata::aligned_size(storage_alignment);
-        let render_group_indirect_size = GpuRenderGroupIndirect::aligned_size(storage_alignment);
-        trace!(
-            "GpuRenderEffectMetadata: min_size={} padded_size={}, GpuRenderGroupIndirect: min_size={} padded_size={}",
-            GpuRenderEffectMetadata::min_size(),
-            render_effect_indirect_size.get(),
-            GpuRenderGroupIndirect::min_size(),
-            render_group_indirect_size.get(),
-        );
-        let render_indirect_layout = render_device.create_bind_group_layout(
+        let render_indirect_layout = create_init_render_indirect_bind_group_layout(
+            render_device,
             "hanabi:bind_group_layout:init_render_indirect",
-            &[
-                // @binding(0) var<storage, read_write> render_effect_indirect :
-                // RenderEffectMetadata
-                BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: ShaderStages::COMPUTE,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Storage { read_only: false },
-                        has_dynamic_offset: true,
-                        min_binding_size: Some(render_effect_indirect_size),
-                    },
-                    count: None,
-                },
-                // @binding(1) var<storage, read_write> render_group_indirect : RenderGroupIndirect
-                BindGroupLayoutEntry {
-                    binding: 1,
-                    visibility: ShaderStages::COMPUTE,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Storage { read_only: false },
-                        has_dynamic_offset: true,
-                        min_binding_size: Some(render_group_indirect_size),
-                    },
-                    count: None,
-                },
-            ],
+            true,
         );
 
         Self {
@@ -617,89 +606,33 @@ impl FromWorld for ParticlesInitPipeline {
     }
 }
 
-#[derive(Clone, Hash, PartialEq, Eq)]
-pub(crate) struct ParticleInitPipelineKey {
-    /// Compute shader, with snippets applied, but not preprocessed yet.
-    shader: Handle<Shader>,
-    /// Minimum binding size in bytes for the particle layout buffer.
-    particle_layout_min_binding_size: NonZeroU64,
-    /// Minimum binding size in bytes for the property layout buffer, if the
-    /// effect has any property. Otherwise this is `None`.
-    property_layout_min_binding_size: Option<NonZeroU64>,
-}
-
 impl SpecializedComputePipeline for ParticlesInitPipeline {
     type Key = ParticleInitPipelineKey;
 
     fn specialize(&self, key: Self::Key) -> ComputePipelineDescriptor {
-        trace!(
-            "GpuParticle: attributes.min_binding_size={} properties.min_binding_size={}",
-            key.particle_layout_min_binding_size.get(),
-            key.property_layout_min_binding_size
-                .map(|sz| sz.get())
-                .unwrap_or(0),
+        let particles_buffer_layout = create_init_particles_bind_group_layout(
+            &self.render_device,
+            "hanabi:init_particles_buffer_layout",
+            key.particle_layout_min_binding_size,
+            key.property_layout_min_binding_size,
         );
 
-        let mut entries = Vec::with_capacity(3);
-        // (1,0) ParticleBuffer
-        entries.push(BindGroupLayoutEntry {
-            binding: 0,
-            visibility: ShaderStages::COMPUTE,
-            ty: BindingType::Buffer {
-                ty: BufferBindingType::Storage { read_only: false },
-                has_dynamic_offset: false,
-                min_binding_size: Some(key.particle_layout_min_binding_size),
-            },
-            count: None,
-        });
-        // (1,1) IndirectBuffer
-        entries.push(BindGroupLayoutEntry {
-            binding: 1,
-            visibility: ShaderStages::COMPUTE,
-            ty: BindingType::Buffer {
-                ty: BufferBindingType::Storage { read_only: false },
-                has_dynamic_offset: false,
-                min_binding_size: BufferSize::new(12),
-            },
-            count: None,
-        });
-        // (1,2) array<ParticleGroup>
-        let particle_group_size = GpuParticleGroup::aligned_size(
-            self.render_device
-                .limits()
-                .min_storage_buffer_offset_alignment,
-        );
-        entries.push(BindGroupLayoutEntry {
-            binding: 2,
-            visibility: ShaderStages::COMPUTE,
-            ty: BindingType::Buffer {
-                ty: BufferBindingType::Storage { read_only: true },
-                has_dynamic_offset: false,
-                min_binding_size: Some(particle_group_size),
-            },
-            count: None,
-        });
-        if let Some(min_binding_size) = key.property_layout_min_binding_size {
-            // (1,3) Properties
-            entries.push(BindGroupLayoutEntry {
-                binding: 3,
-                visibility: ShaderStages::COMPUTE,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Storage { read_only: true },
-                    has_dynamic_offset: false, // TODO
-                    min_binding_size: Some(min_binding_size),
-                },
-                count: None,
-            });
+        let mut shader_defs = vec![];
+        if key.flags.contains(ParticleInitPipelineKeyFlags::CLONE) {
+            shader_defs.push(ShaderDefVal::Bool("CLONE".to_string(), true));
+        }
+        if key
+            .flags
+            .contains(ParticleInitPipelineKeyFlags::ATTRIBUTE_PREV)
+        {
+            shader_defs.push(ShaderDefVal::Bool("ATTRIBUTE_PREV".to_string(), true));
+        }
+        if key
+            .flags
+            .contains(ParticleInitPipelineKeyFlags::ATTRIBUTE_NEXT)
+        {
+            shader_defs.push(ShaderDefVal::Bool("ATTRIBUTE_NEXT".to_string(), true));
         }
-
-        let label = "hanabi:init_particles_buffer_layout";
-        trace!(
-            "Creating particle bind group layout '{}' for init pass with {} entries.",
-            label,
-            entries.len()
-        );
-        let particles_buffer_layout = self.render_device.create_bind_group_layout(label, &entries);
 
         ComputePipelineDescriptor {
             label: Some("hanabi:pipeline_init_compute".into()),
@@ -710,9 +643,9 @@ impl SpecializedComputePipeline for ParticlesInitPipeline {
                 self.render_indirect_layout.clone(),
             ],
             shader: key.shader,
-            shader_defs: vec![],
+            shader_defs,
             entry_point: "main".into(),
-            push_constant_ranges: Vec::new(),
+            push_constant_ranges: vec![],
         }
     }
 }
@@ -821,6 +754,7 @@ pub(crate) struct ParticleUpdatePipelineKey {
     particle_layout: ParticleLayout,
     /// Property layout.
     property_layout: PropertyLayout,
+    is_trail: bool,
 }
 
 impl SpecializedComputePipeline for ParticlesUpdatePipeline {
@@ -837,68 +771,27 @@ impl SpecializedComputePipeline for ParticlesUpdatePipeline {
             },
         );
 
-        let particle_group_size = GpuParticleGroup::aligned_size(
-            self.render_device
-                .limits()
-                .min_storage_buffer_offset_alignment,
-        );
-        let mut entries = vec![
-            // @binding(0) var<storage, read_write> particle_buffer : ParticleBuffer
-            BindGroupLayoutEntry {
-                binding: 0,
-                visibility: ShaderStages::COMPUTE,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Storage { read_only: false },
-                    has_dynamic_offset: false,
-                    min_binding_size: Some(key.particle_layout.min_binding_size()),
-                },
-                count: None,
-            },
-            // @binding(1) var<storage, read_write> indirect_buffer : IndirectBuffer
-            BindGroupLayoutEntry {
-                binding: 1,
-                visibility: ShaderStages::COMPUTE,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Storage { read_only: false },
-                    has_dynamic_offset: false,
-                    min_binding_size: BufferSize::new(INDIRECT_INDEX_SIZE as _),
-                },
-                count: None,
-            },
-            // @binding(2) var<storage, read> particle_groups : array<ParticleGroup>
-            BindGroupLayoutEntry {
-                binding: 2,
-                visibility: ShaderStages::COMPUTE,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Storage { read_only: true },
-                    has_dynamic_offset: false,
-                    min_binding_size: Some(particle_group_size),
-                },
-                count: None,
+        let update_particles_buffer_layout = create_update_bind_group_layout(
+            &self.render_device,
+            "hanabi:update_particles_buffer_layout",
+            key.particle_layout.min_binding_size(),
+            if key.property_layout.is_empty() {
+                None
+            } else {
+                Some(key.property_layout.min_binding_size())
             },
-        ];
-        if !key.property_layout.is_empty() {
-            // @binding(3) var<storage, read> properties : Properties
-            entries.push(BindGroupLayoutEntry {
-                binding: 3,
-                visibility: ShaderStages::COMPUTE,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Storage { read_only: true },
-                    has_dynamic_offset: false, // TODO
-                    min_binding_size: Some(key.property_layout.min_binding_size()),
-                },
-                count: None,
-            });
-        }
-
-        let label = "hanabi:update_particles_buffer_layout";
-        trace!(
-            "Creating particle bind group layout '{}' for update pass with {} entries.",
-            label,
-            entries.len()
         );
-        let update_particles_buffer_layout =
-            self.render_device.create_bind_group_layout(label, &entries);
+
+        let mut shader_defs = vec!["REM_MAX_SPAWN_ATOMIC".into()];
+        if key.particle_layout.contains(Attribute::PREV) {
+            shader_defs.push("ATTRIBUTE_PREV".into());
+        }
+        if key.particle_layout.contains(Attribute::NEXT) {
+            shader_defs.push("ATTRIBUTE_NEXT".into());
+        }
+        if key.is_trail {
+            shader_defs.push("TRAIL".into());
+        }
 
         ComputePipelineDescriptor {
             label: Some("hanabi:pipeline_update_compute".into()),
@@ -909,7 +802,7 @@ impl SpecializedComputePipeline for ParticlesUpdatePipeline {
                 self.render_indirect_layout.clone(),
             ],
             shader: key.shader,
-            shader_defs: vec!["REM_MAX_SPAWN_ATOMIC".into()],
+            shader_defs,
             entry_point: "main".into(),
             push_constant_ranges: Vec::new(),
         }
@@ -1048,6 +941,9 @@ pub(crate) struct ParticleRenderPipelineKey {
     /// Key: NEEDS_UV
     /// The effect needs UVs.
     needs_uv: bool,
+    /// Key: RIBBONS
+    /// The effect has ribbons.
+    ribbons: bool,
     /// For dual-mode configurations only, the actual mode of the current render
     /// pipeline. Otherwise the mode is implicitly determined by the active
     /// feature.
@@ -1070,6 +966,7 @@ impl Default for ParticleRenderPipelineKey {
             alpha_mode: AlphaMode::Blend,
             flipbook: false,
             needs_uv: false,
+            ribbons: false,
             #[cfg(all(feature = "2d", feature = "3d"))]
             pipeline_mode: PipelineMode::Camera3d,
             msaa_samples: Msaa::default().samples(),
@@ -1214,10 +1111,16 @@ impl SpecializedRenderPipeline for ParticlesRenderPipeline {
             shader_defs.push("FLIPBOOK".into());
         }
 
+        // Key: NEEDS_UV
         if key.needs_uv {
             shader_defs.push("NEEDS_UV".into());
         }
 
+        // Key: RIBBONS
+        if key.ribbons {
+            shader_defs.push("RIBBONS".into());
+        }
+
         #[cfg(all(feature = "2d", feature = "3d"))]
         let depth_stencil = match key.pipeline_mode {
             // Bevy's Transparent2d render phase doesn't support a depth-stencil buffer.
@@ -1341,13 +1244,13 @@ pub(crate) struct ExtractedEffect {
     ///
     /// [`property_layout`]: crate::render::ExtractedEffect::property_layout
     pub property_data: Option<Vec<u8>>,
-    /// Number of particles to spawn this frame for the effect.
+    /// Maps a group number to the runtime initializer for that group.
     ///
     /// Obtained from calling [`EffectSpawner::tick()`] on the source effect
     /// instance.
     ///
     /// [`EffectSpawner::tick()`]: crate::EffectSpawner::tick
-    pub spawn_count: u32,
+    pub initializers: Vec<EffectInitializer>,
     /// Global transform of the effect origin, extracted from the
     /// [`GlobalTransform`].
     pub transform: Mat4,
@@ -1362,8 +1265,8 @@ pub(crate) struct ExtractedEffect {
     pub textures: Vec<Handle<Image>>,
     /// Alpha mode.
     pub alpha_mode: AlphaMode,
-    /// Effect shader.
-    pub effect_shader: EffectShader,
+    /// Effect shaders.
+    pub effect_shaders: Vec<EffectShader>,
     /// For 2D rendering, the Z coordinate used as the sort key. Ignored for 3D
     /// rendering.
     #[cfg(feature = "2d")]
@@ -1379,9 +1282,7 @@ pub struct AddedEffect {
     ///
     /// [`ParticleEffect`]: crate::ParticleEffect
     pub entity: Entity,
-    /// Capacity of the effect (and therefore, the particle buffer), in number
-    /// of particles.
-    pub capacities: Vec<u32>,
+    pub groups: Vec<AddedEffectGroup>,
     /// Layout of particle attributes.
     pub particle_layout: ParticleLayout,
     /// Layout of properties for the effect, if properties are used at all, or
@@ -1392,6 +1293,11 @@ pub struct AddedEffect {
     pub handle: Handle<EffectAsset>,
 }
 
+pub struct AddedEffectGroup {
+    pub capacity: u32,
+    pub src_group_index_if_trail: Option<u32>,
+}
+
 /// Collection of all extracted effects for this frame, inserted into the
 /// render world as a render resource.
 #[derive(Default, Resource)]
@@ -1452,7 +1358,7 @@ pub(crate) fn extract_effects(
                 Entity,
                 Option<&InheritedVisibility>,
                 Option<&ViewVisibility>,
-                &EffectSpawner,
+                &EffectInitializers,
                 &CompiledParticleEffect,
                 Option<Ref<EffectProperties>>,
                 &GlobalTransform,
@@ -1509,10 +1415,26 @@ pub(crate) fn extract_effects(
             );
             let property_layout = asset.property_layout();
 
-            trace!("Found new effect: entity {:?} | capacities {:?} | particle_layout {:?} | property_layout {:?} | layout_flags {:?}", entity, asset.capacities(), particle_layout, property_layout, effect.layout_flags);
+            trace!(
+                "Found new effect: entity {:?} | capacities {:?} | particle_layout {:?} | \
+                 property_layout {:?} | layout_flags {:?}",
+                 entity,
+                 asset.capacities(),
+                 particle_layout,
+                 property_layout,
+                 effect.layout_flags);
+
             Some(AddedEffect {
                 entity,
-                capacities: asset.capacities().to_vec(),
+                groups: asset.capacities().iter().zip(asset.init.iter()).map(|(&capacity, init)| {
+                    AddedEffectGroup {
+                        capacity,
+                        src_group_index_if_trail: match init {
+                            Initializer::Spawner(_) => None,
+                            Initializer::Cloner(cloner) => Some(cloner.src_group_index),
+                        }
+                    }
+                }).collect(),
                 particle_layout,
                 property_layout,
                 layout_flags: effect.layout_flags,
@@ -1527,16 +1449,17 @@ pub(crate) fn extract_effects(
         entity,
         maybe_inherited_visibility,
         maybe_view_visibility,
-        spawner,
+        initializers,
         effect,
         maybe_properties,
         transform,
     ) in query.p0().iter_mut()
     {
         // Check if shaders are configured
-        let Some(effect_shader) = effect.get_configured_shader() else {
+        let effect_shaders = effect.get_configured_shaders().to_vec();
+        if effect_shaders.is_empty() {
             continue;
-        };
+        }
 
         // Check if hidden, unless always simulated
         if effect.simulation_condition == SimulationCondition::WhenVisible
@@ -1597,7 +1520,7 @@ pub(crate) fn extract_effects(
                 particle_layout: asset.particle_layout().clone(),
                 property_layout,
                 property_data,
-                spawn_count: spawner.spawn_count,
+                initializers: initializers.0.clone(),
                 transform: transform.compute_matrix(),
                 // TODO - more efficient/correct way than inverse()?
                 inverse_transform: transform.compute_matrix().inverse(),
@@ -1605,7 +1528,7 @@ pub(crate) fn extract_effects(
                 texture_layout,
                 textures: effect.textures.clone(),
                 alpha_mode,
-                effect_shader,
+                effect_shaders,
                 #[cfg(feature = "2d")]
                 z_sort_key_2d,
             },
@@ -1918,44 +1841,60 @@ impl EffectsMeta {
 
         trace!("Adding {} newly spawned effects", added_effects.len());
         for added_effect in added_effects.drain(..) {
-            let total_capacity = added_effect.capacities.iter().cloned().sum();
-
             let first_update_group_dispatch_buffer_index = allocate_sequential_buffers(
                 &mut self.dispatch_indirect_buffer,
-                iter::repeat(GpuDispatchIndirect::default()).take(added_effect.capacities.len()),
+                iter::repeat(GpuDispatchIndirect::default()).take(added_effect.groups.len()),
             );
 
-            let render_effect_dispatch_buffer_id =
-                self.render_effect_dispatch_buffer
-                    .insert(GpuRenderEffectMetadata {
-                        max_spawn: total_capacity,
-                        ..default()
-                    });
+            let render_effect_dispatch_buffer_id = self
+                .render_effect_dispatch_buffer
+                .insert(GpuRenderEffectMetadata::default());
 
             let mut current_base_instance = 0;
             let first_render_group_dispatch_buffer_index = allocate_sequential_buffers(
                 &mut self.render_group_dispatch_buffer,
-                added_effect.capacities.iter().map(|&capacity| {
+                added_effect.groups.iter().map(|group| {
                     let indirect_dispatch = GpuRenderGroupIndirect {
                         vertex_count: 6, // TODO - Flexible vertex count and mesh particles
-                        dead_count: capacity,
+                        dead_count: group.capacity,
                         base_instance: current_base_instance,
+                        max_spawn: group.capacity,
                         ..default()
                     };
-                    current_base_instance += capacity;
+                    current_base_instance += group.capacity;
                     indirect_dispatch
                 }),
             );
 
+            let mut trail_dispatch_buffer_indices = HashMap::new();
+            for (dest_group_index, group) in added_effect.groups.iter().enumerate() {
+                let Some(src_group_index) = group.src_group_index_if_trail else {
+                    continue;
+                };
+                trail_dispatch_buffer_indices.insert(
+                    dest_group_index as u32,
+                    TrailDispatchBufferIndices {
+                        dest: first_render_group_dispatch_buffer_index
+                            .offset(dest_group_index as u32),
+                        src: first_render_group_dispatch_buffer_index.offset(src_group_index),
+                    },
+                );
+            }
+
             let dispatch_buffer_indices = DispatchBufferIndices {
                 first_update_group_dispatch_buffer_index,
                 render_effect_metadata_buffer_index: render_effect_dispatch_buffer_id,
                 first_render_group_dispatch_buffer_index,
+                trail_dispatch_buffer_indices,
             };
 
             let cache_id = effect_cache.insert(
                 added_effect.handle,
-                added_effect.capacities,
+                added_effect
+                    .groups
+                    .iter()
+                    .map(|group| group.capacity)
+                    .collect(),
                 &added_effect.particle_layout,
                 &added_effect.property_layout,
                 added_effect.layout_flags,
@@ -2041,6 +1980,8 @@ bitflags! {
         const FLIPBOOK = (1 << 4);
         /// The effect needs UVs.
         const NEEDS_UV = (1 << 5);
+        /// The effect has ribbons.
+        const RIBBONS = (1 << 6);
     }
 }
 
@@ -2129,16 +2070,17 @@ pub(crate) fn prepare_effects(
                 entity,
                 effect_slices,
                 property_layout: extracted_effect.property_layout.clone(),
-                effect_shader: extracted_effect.effect_shader.clone(),
+                effect_shaders: extracted_effect.effect_shaders.clone(),
                 layout_flags: extracted_effect.layout_flags,
                 texture_layout: extracted_effect.texture_layout.clone(),
                 textures: extracted_effect.textures.clone(),
                 alpha_mode: extracted_effect.alpha_mode,
-                spawn_count: extracted_effect.spawn_count,
                 transform: extracted_effect.transform.into(),
                 inverse_transform: extracted_effect.inverse_transform.into(),
+                particle_layout: extracted_effect.particle_layout.clone(),
                 property_buffer,
                 property_data: extracted_effect.property_data,
+                initializers: extracted_effect.initializers,
                 #[cfg(feature = "2d")]
                 z_sort_key_2d: extracted_effect.z_sort_key_2d,
             }
@@ -2160,67 +2102,95 @@ pub(crate) fn prepare_effects(
     effects_meta.particle_group_buffer.clear();
     let mut total_group_count = 0;
     for (effect_index, input) in effect_entity_list.into_iter().enumerate() {
-        // Specialize the init pipeline based on the effect. Note that this is shared by
-        // all effect groups of a same effect.
-        trace!(
-            "Specializing compute pipeline: init_shader={:?} particle_layout={:?}",
-            input.effect_shader.init,
-            input.effect_slices.particle_layout
+        let particle_layout_min_binding_size =
+            input.effect_slices.particle_layout.min_binding_size();
+        let property_layout_min_binding_size = if input.property_layout.is_empty() {
+            None
+        } else {
+            Some(input.property_layout.min_binding_size())
+        };
+
+        // Create init pipeline key flags.
+        let mut init_pipeline_key_flags = ParticleInitPipelineKeyFlags::empty();
+        init_pipeline_key_flags.set(
+            ParticleInitPipelineKeyFlags::ATTRIBUTE_PREV,
+            input.particle_layout.contains(Attribute::PREV),
         );
-        let init_pipeline_id = specialized_init_pipelines.specialize(
-            &pipeline_cache,
-            &init_pipeline,
-            ParticleInitPipelineKey {
-                shader: input.effect_shader.init.clone(),
-                particle_layout_min_binding_size: input
-                    .effect_slices
-                    .particle_layout
-                    .min_binding_size(),
-                property_layout_min_binding_size: if input.property_layout.is_empty() {
-                    None
-                } else {
-                    Some(input.property_layout.min_binding_size())
-                },
-            },
+        init_pipeline_key_flags.set(
+            ParticleInitPipelineKeyFlags::ATTRIBUTE_NEXT,
+            input.particle_layout.contains(Attribute::NEXT),
         );
-        trace!("Init pipeline specialized: id={:?}", init_pipeline_id);
 
-        // Specialize the update pipelines based on the effect
-        trace!(
-            "Specializing update pipeline(s): update_shader(s)={:?} particle_layout={:?} property_layout={:?}",
-            input.effect_shader.update,
-            input.effect_slices.particle_layout,
-            input.property_layout,
-        );
-        let update_pipeline_ids: Vec<_> = input
-            .effect_shader
-            .update
+        // Specialize the init pipeline based on the effect.
+        let init_and_update_pipeline_ids = input
+            .effect_shaders
             .iter()
-            .map(|update_source| {
-                specialized_update_pipelines.specialize(
+            .enumerate()
+            .map(|(group_index, shader)| {
+                let mut flags = init_pipeline_key_flags;
+
+                // If this is a cloner, add the appropriate flag.
+                match input.initializers[group_index] {
+                    EffectInitializer::Spawner(_) => {}
+                    EffectInitializer::Cloner(_) => {
+                        flags.insert(ParticleInitPipelineKeyFlags::CLONE);
+                    }
+                }
+
+                let init_pipeline_id = specialized_init_pipelines.specialize(
+                    &pipeline_cache,
+                    &init_pipeline,
+                    ParticleInitPipelineKey {
+                        shader: shader.init.clone(),
+                        particle_layout_min_binding_size,
+                        property_layout_min_binding_size,
+                        flags,
+                    },
+                );
+                trace!("Init pipeline specialized: id={:?}", init_pipeline_id);
+
+                let update_pipeline_id = specialized_update_pipelines.specialize(
                     &pipeline_cache,
                     &update_pipeline,
                     ParticleUpdatePipelineKey {
-                        shader: update_source.clone(),
+                        shader: shader.update.clone(),
                         particle_layout: input.effect_slices.particle_layout.clone(),
                         property_layout: input.property_layout.clone(),
+                        is_trail: matches!(
+                            input.initializers[group_index],
+                            EffectInitializer::Cloner(_)
+                        ),
                     },
-                )
+                );
+                trace!("Update pipeline specialized: id={:?}", update_pipeline_id);
+
+                InitAndUpdatePipelineIds {
+                    init: init_pipeline_id,
+                    update: update_pipeline_id,
+                }
             })
             .collect();
-        trace!(
-            "Update pipeline(s) specialized: ids={:?}",
-            update_pipeline_ids
-        );
 
-        let init_shader = input.effect_shader.init.clone();
-        trace!("init_shader = {:?}", init_shader);
+        let init_shaders: Vec<_> = input
+            .effect_shaders
+            .iter()
+            .map(|shaders| shaders.init.clone())
+            .collect();
+        trace!("init_shader(s) = {:?}", init_shaders);
 
-        let update_shader = input.effect_shader.update.clone();
-        trace!("update_shader(s) = {:?}", update_shader);
+        let update_shaders: Vec<_> = input
+            .effect_shaders
+            .iter()
+            .map(|shaders| shaders.update.clone())
+            .collect();
+        trace!("update_shader(s) = {:?}", update_shaders);
 
-        let render_shader = input.effect_shader.render.clone();
-        trace!("render_shader(s) = {:?}", render_shader);
+        let render_shaders: Vec<_> = input
+            .effect_shaders
+            .iter()
+            .map(|shaders| shaders.render.clone())
+            .collect();
+        trace!("render_shader(s) = {:?}", render_shaders);
 
         let layout_flags = input.layout_flags;
         trace!("layout_flags = {:?}", layout_flags);
@@ -2240,20 +2210,47 @@ pub(crate) fn prepare_effects(
         // will be pushed in order into the array.
         let spawner_base = effects_meta.spawner_buffer.len() as u32;
 
-        let spawner_params = GpuSpawnerParams {
-            transform: input.transform,
-            inverse_transform: input.inverse_transform,
-            spawn: input.spawn_count as i32,
-            // FIXME - Probably bad to re-seed each time there's a change
-            seed: random::<u32>(),
-            count: 0,
-            // FIXME: the effect_index is global inside the global spawner buffer,
-            // but the group_index is the index of the particle buffer, which can
-            // in theory (with batching) contain > 1 effect per buffer.
-            effect_index: input.effect_slices.buffer_index,
-        };
-        trace!("spawner_params = {:?}", spawner_params);
-        effects_meta.spawner_buffer.push(spawner_params);
+        for initializer in input.initializers.iter() {
+            match initializer {
+                EffectInitializer::Spawner(effect_spawner) => {
+                    let spawner_params = GpuSpawnerParams {
+                        transform: input.transform,
+                        inverse_transform: input.inverse_transform,
+                        spawn: effect_spawner.spawn_count as i32,
+                        // FIXME - Probably bad to re-seed each time there's a change
+                        seed: random::<u32>(),
+                        count: 0,
+                        // FIXME: the effect_index is global inside the global spawner buffer,
+                        // but the group_index is the index of the particle buffer, which can
+                        // in theory (with batching) contain > 1 effect per buffer.
+                        effect_index: input.effect_slices.buffer_index,
+                        lifetime: 0.0,
+                        pad: Default::default(),
+                    };
+                    trace!("spawner params = {:?}", spawner_params);
+                    effects_meta.spawner_buffer.push(spawner_params);
+                }
+
+                EffectInitializer::Cloner(effect_cloner) => {
+                    let spawner_params = GpuSpawnerParams {
+                        transform: input.transform,
+                        inverse_transform: input.inverse_transform,
+                        spawn: 0,
+                        // FIXME - Probably bad to re-seed each time there's a change
+                        seed: random::<u32>(),
+                        count: 0,
+                        // FIXME: the effect_index is global inside the global spawner buffer,
+                        // but the group_index is the index of the particle buffer, which can
+                        // in theory (with batching) contain > 1 effect per buffer.
+                        effect_index: input.effect_slices.buffer_index,
+                        lifetime: effect_cloner.cloner.lifetime,
+                        pad: Default::default(),
+                    };
+                    trace!("cloner params = {:?}", spawner_params);
+                    effects_meta.spawner_buffer.push(spawner_params);
+                }
+            }
+        }
 
         // Create the particle group buffer entries.
         let mut first_particle_group_buffer_index = None;
@@ -2276,7 +2273,9 @@ pub(crate) fn prepare_effects(
         }
 
         let effect_cache_id = effects_meta.entity_map.get(&input.entity).unwrap().cache_id;
-        let dispatch_buffer_indices = effect_cache.get_dispatch_buffer_indices(effect_cache_id);
+        let dispatch_buffer_indices = effect_cache
+            .get_dispatch_buffer_indices(effect_cache_id)
+            .clone();
 
         // Write properties for this effect if they were modified.
         // FIXME - This doesn't work with batching!
@@ -2303,8 +2302,7 @@ pub(crate) fn prepare_effects(
             input,
             spawner_base,
             effect_cache_id,
-            init_pipeline_id,
-            update_pipeline_ids,
+            init_and_update_pipeline_ids,
             dispatch_buffer_indices,
             first_particle_group_buffer_index.unwrap_or_default(),
         );
@@ -2558,6 +2556,7 @@ fn emit_sorted_draw<T, F>(
             let use_alpha_mask = batches.layout_flags.contains(LayoutFlags::USE_ALPHA_MASK);
             let flipbook = batches.layout_flags.contains(LayoutFlags::FLIPBOOK);
             let needs_uv = batches.layout_flags.contains(LayoutFlags::NEEDS_UV);
+            let ribbons = batches.layout_flags.contains(LayoutFlags::RIBBONS);
             let image_count = batches.texture_layout.layout.len() as u8;
 
             // Specialize the render pipeline based on the effect batch
@@ -2591,6 +2590,7 @@ fn emit_sorted_draw<T, F>(
                     alpha_mode,
                     flipbook,
                     needs_uv,
+                    ribbons,
                     #[cfg(all(feature = "2d", feature = "3d"))]
                     pipeline_mode,
                     msaa_samples,
@@ -2732,6 +2732,7 @@ fn emit_binned_draw<T, F>(
             let use_alpha_mask = batches.layout_flags.contains(LayoutFlags::USE_ALPHA_MASK);
             let flipbook = batches.layout_flags.contains(LayoutFlags::FLIPBOOK);
             let needs_uv = batches.layout_flags.contains(LayoutFlags::NEEDS_UV);
+            let ribbons = batches.layout_flags.contains(LayoutFlags::RIBBONS);
             let image_count = batches.texture_layout.layout.len() as u8;
 
             // Specialize the render pipeline based on the effect batch
@@ -2765,6 +2766,7 @@ fn emit_binned_draw<T, F>(
                     alpha_mode,
                     flipbook,
                     needs_uv,
+                    ribbons,
                     #[cfg(all(feature = "2d", feature = "3d"))]
                     pipeline_mode,
                     msaa_samples,
@@ -2800,7 +2802,6 @@ fn emit_binned_draw<T, F>(
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn queue_effects(
     views: Query<(Entity, &VisibleEntities, &ExtractedView)>,
-    effects_meta: Res<EffectsMeta>,
     mut render_pipeline: ResMut<ParticlesRenderPipeline>,
     mut specialized_render_pipelines: ResMut<SpecializedRenderPipelines<ParticlesRenderPipeline>>,
     pipeline_cache: Res<PipelineCache>,
@@ -2843,11 +2844,6 @@ pub(crate) fn queue_effects(
         };
     }
 
-    if effects_meta.spawner_buffer.buffer().is_none() || effects_meta.spawner_buffer.is_empty() {
-        // No spawners are active
-        return;
-    }
-
     // Loop over all 2D cameras/views that need to render effects
     #[cfg(feature = "2d")]
     {
@@ -3017,10 +3013,6 @@ pub(crate) fn prepare_bind_groups(
     render_pipeline: ResMut<ParticlesRenderPipeline>,
     gpu_images: Res<RenderAssets<GpuImage>>,
 ) {
-    if effects_meta.spawner_buffer.is_empty() || effects_meta.spawner_buffer.buffer().is_none() {
-        return;
-    }
-
     {
         #[cfg(feature = "trace")]
         let _span = bevy::utils::tracing::info_span!("shared_bind_groups").entered();
@@ -3053,96 +3045,141 @@ pub(crate) fn prepare_bind_groups(
         // Note: we clear effects_meta.spawner_buffer each frame in prepare_effects(),
         // so this bind group is always invalid at the minute and always needs
         // re-creation.
-        effects_meta.spawner_bind_group = Some(render_device.create_bind_group(
-            "hanabi:bind_group_spawner_buffer",
-            &update_pipeline.spawner_buffer_layout, // FIXME - Shared with init,is that OK?
-            &[BindGroupEntry {
-                binding: 0,
-                resource: BindingResource::Buffer(BufferBinding {
-                    buffer: effects_meta.spawner_buffer.buffer().unwrap(),
-                    offset: 0,
-                    size: Some(
-                        NonZeroU64::new(effects_meta.spawner_buffer.aligned_size() as u64).unwrap(),
-                    ),
-                }),
-            }],
-        ));
-
-        // Create the bind group for the indirect dispatch of all effects
-        effects_meta.dr_indirect_bind_group = Some(render_device.create_bind_group(
-            "hanabi:bind_group_vfx_indirect_dr_indirect",
-            &dispatch_indirect_pipeline.dispatch_indirect_layout,
-            &[
-                BindGroupEntry {
+        effects_meta.spawner_bind_group = effects_meta.spawner_buffer.buffer().map(|buffer| {
+            render_device.create_bind_group(
+                "hanabi:bind_group_spawner_buffer",
+                &update_pipeline.spawner_buffer_layout, // FIXME - Shared with init,is that OK?
+                &[BindGroupEntry {
                     binding: 0,
                     resource: BindingResource::Buffer(BufferBinding {
-                        buffer: effects_meta.render_effect_dispatch_buffer.buffer().unwrap(),
-                        offset: 0,
-                        size: None, //NonZeroU64::new(256), // Some(GpuRenderIndirect::min_size()),
-                    }),
-                },
-                BindGroupEntry {
-                    binding: 1,
-                    resource: BindingResource::Buffer(BufferBinding {
-                        buffer: effects_meta.render_group_dispatch_buffer.buffer().unwrap(),
-                        offset: 0,
-                        size: None, //NonZeroU64::new(256), // Some(GpuRenderIndirect::min_size()),
-                    }),
-                },
-                BindGroupEntry {
-                    binding: 2,
-                    resource: BindingResource::Buffer(BufferBinding {
-                        buffer: effects_meta.dispatch_indirect_buffer.buffer().unwrap(),
-                        offset: 0,
-                        size: None, //NonZeroU64::new(256), // Some(GpuDispatchIndirect::min_size()),
-                    }),
-                },
-                BindGroupEntry {
-                    binding: 3,
-                    resource: BindingResource::Buffer(BufferBinding {
-                        buffer: effects_meta.particle_group_buffer.buffer().unwrap(),
+                        buffer,
                         offset: 0,
-                        size: None,
+                        size: Some(
+                            NonZeroU64::new(effects_meta.spawner_buffer.aligned_size() as u64)
+                                .unwrap(),
+                        ),
                     }),
-                },
-            ],
-        ));
+                }],
+            )
+        });
+
+        // Create the bind group for the indirect dispatch of all effects
+        effects_meta.dr_indirect_bind_group = match (
+            effects_meta.render_effect_dispatch_buffer.buffer(),
+            effects_meta.render_group_dispatch_buffer.buffer(),
+            effects_meta.dispatch_indirect_buffer.buffer(),
+            effects_meta.particle_group_buffer.buffer(),
+            effects_meta.spawner_buffer.buffer(),
+        ) {
+            (
+                Some(render_effect_dispatch_buffer),
+                Some(render_group_dispatch_buffer),
+                Some(dispatch_indirect_buffer),
+                Some(particle_group_buffer),
+                Some(spawner_buffer),
+            ) => {
+                Some(render_device.create_bind_group(
+                    "hanabi:bind_group_vfx_indirect_dr_indirect",
+                    &dispatch_indirect_pipeline.dispatch_indirect_layout,
+                    &[
+                        BindGroupEntry {
+                            binding: 0,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: render_effect_dispatch_buffer,
+                                offset: 0,
+                                size: None, //NonZeroU64::new(256), // Some(GpuRenderIndirect::min_size()),
+                            }),
+                        },
+                        BindGroupEntry {
+                            binding: 1,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: render_group_dispatch_buffer,
+                                offset: 0,
+                                size: None, //NonZeroU64::new(256), // Some(GpuRenderIndirect::min_size()),
+                            }),
+                        },
+                        BindGroupEntry {
+                            binding: 2,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: dispatch_indirect_buffer,
+                                offset: 0,
+                                size: None, //NonZeroU64::new(256), // Some(GpuDispatchIndirect::min_size()),
+                            }),
+                        },
+                        BindGroupEntry {
+                            binding: 3,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: particle_group_buffer,
+                                offset: 0,
+                                size: None,
+                            }),
+                        },
+                        BindGroupEntry {
+                            binding: 4,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: spawner_buffer,
+                                offset: 0,
+                                size: None,
+                            }),
+                        },
+                    ],
+                ))
+            }
+            _ => None,
+        };
+
+        let init_render_indirect_bind_group = match (
+            effects_meta.render_effect_dispatch_buffer.buffer(),
+            effects_meta.render_group_dispatch_buffer.buffer(),
+        ) {
+            (Some(render_effect_dispatch_buffer), Some(render_group_dispatch_buffer)) => {
+                Some(render_device.create_bind_group(
+                    "hanabi:bind_group_init_render_dispatch",
+                    &init_pipeline.render_indirect_layout,
+                    &[
+                        BindGroupEntry {
+                            binding: 0,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: render_effect_dispatch_buffer,
+                                offset: 0,
+                                size: Some(effects_meta.gpu_limits.render_effect_indirect_size()),
+                            }),
+                        },
+                        BindGroupEntry {
+                            binding: 1,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: render_group_dispatch_buffer,
+                                offset: 0,
+                                size: Some(effects_meta.gpu_limits.render_group_indirect_size()),
+                            }),
+                        },
+                        BindGroupEntry {
+                            binding: 2,
+                            resource: BindingResource::Buffer(BufferBinding {
+                                buffer: render_group_dispatch_buffer,
+                                offset: 0,
+                                size: Some(effects_meta.gpu_limits.render_group_indirect_size()),
+                            }),
+                        },
+                    ],
+                ))
+            }
+
+            (_, _) => None,
+        };
 
         // Create the bind group for the indirect render buffer use in the init shader
-        effects_meta.init_render_indirect_bind_group = Some(render_device.create_bind_group(
-            "hanabi:bind_group_init_render_dispatch",
-            &init_pipeline.render_indirect_layout,
-            &[
-                BindGroupEntry {
-                    binding: 0,
-                    resource: BindingResource::Buffer(BufferBinding {
-                        buffer: effects_meta.render_effect_dispatch_buffer.buffer().unwrap(),
-                        offset: 0,
-                        size: Some(effects_meta.gpu_limits.render_effect_indirect_size()),
-                    }),
-                },
-                BindGroupEntry {
-                    binding: 1,
-                    resource: BindingResource::Buffer(BufferBinding {
-                        buffer: effects_meta.render_group_dispatch_buffer.buffer().unwrap(),
-                        // Always bind the first array element of the buffer, corresponding to the
-                        // first effect group, as only the first group has an init pass.
-                        offset: 0,
-                        size: Some(effects_meta.gpu_limits.render_group_indirect_size()),
-                    }),
-                },
-            ],
-        ));
+        effects_meta.init_render_indirect_bind_group = init_render_indirect_bind_group;
     }
 
     // Make a copy of the buffer ID before borrowing effects_meta mutably in the
     // loop below
-    let indirect_buffer = effects_meta
-        .dispatch_indirect_buffer
-        .buffer()
-        .cloned()
-        .unwrap();
-    let spawner_buffer = effects_meta.spawner_buffer.buffer().cloned().unwrap();
+    let Some(indirect_buffer) = effects_meta.dispatch_indirect_buffer.buffer().cloned() else {
+        return;
+    };
+    let Some(spawner_buffer) = effects_meta.spawner_buffer.buffer().cloned() else {
+        return;
+    };
 
     // Create the per-effect render bind groups
     trace!("Create per-effect render bind groups...");
@@ -3551,6 +3588,187 @@ impl Draw<AlphaMask3d> for DrawEffects {
     }
 }
 
+fn create_init_particles_bind_group_layout(
+    render_device: &RenderDevice,
+    label: &str,
+    particle_layout_min_binding_size: NonZero<u64>,
+    property_layout_min_binding_size: Option<NonZero<u64>>,
+) -> BindGroupLayout {
+    let mut entries = Vec::with_capacity(3);
+    // (1,0) ParticleBuffer
+    entries.push(BindGroupLayoutEntry {
+        binding: 0,
+        visibility: ShaderStages::COMPUTE,
+        ty: BindingType::Buffer {
+            ty: BufferBindingType::Storage { read_only: false },
+            has_dynamic_offset: false,
+            min_binding_size: Some(particle_layout_min_binding_size),
+        },
+        count: None,
+    });
+    // (1,1) IndirectBuffer
+    entries.push(BindGroupLayoutEntry {
+        binding: 1,
+        visibility: ShaderStages::COMPUTE,
+        ty: BindingType::Buffer {
+            ty: BufferBindingType::Storage { read_only: false },
+            has_dynamic_offset: false,
+            min_binding_size: BufferSize::new(12),
+        },
+        count: None,
+    });
+    // (1,2) array<ParticleGroup>
+    let particle_group_size =
+        GpuParticleGroup::aligned_size(render_device.limits().min_storage_buffer_offset_alignment);
+    entries.push(BindGroupLayoutEntry {
+        binding: 2,
+        visibility: ShaderStages::COMPUTE,
+        ty: BindingType::Buffer {
+            ty: BufferBindingType::Storage { read_only: true },
+            has_dynamic_offset: false,
+            min_binding_size: Some(particle_group_size),
+        },
+        count: None,
+    });
+    if let Some(min_binding_size) = property_layout_min_binding_size {
+        // (1,3) Properties
+        entries.push(BindGroupLayoutEntry {
+            binding: 3,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: true },
+                has_dynamic_offset: false, // TODO
+                min_binding_size: Some(min_binding_size),
+            },
+            count: None,
+        });
+    }
+
+    trace!(
+        "Creating particle bind group layout '{}' for init pass with {} entries.",
+        label,
+        entries.len()
+    );
+    render_device.create_bind_group_layout(label, &entries)
+}
+
+fn create_init_render_indirect_bind_group_layout(
+    render_device: &RenderDevice,
+    label: &str,
+    clone: bool,
+) -> BindGroupLayout {
+    let storage_alignment = render_device.limits().min_storage_buffer_offset_alignment;
+    let render_effect_indirect_size = GpuRenderEffectMetadata::aligned_size(storage_alignment);
+    let render_group_indirect_size = GpuRenderGroupIndirect::aligned_size(storage_alignment);
+
+    let mut entries = vec![
+        // @binding(0) var<storage, read_write> render_effect_indirect :
+        // RenderEffectMetadata
+        BindGroupLayoutEntry {
+            binding: 0,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: false },
+                has_dynamic_offset: true,
+                min_binding_size: Some(render_effect_indirect_size),
+            },
+            count: None,
+        },
+        // @binding(1) var<storage, read_write> dest_render_group_indirect : RenderGroupIndirect
+        BindGroupLayoutEntry {
+            binding: 1,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: false },
+                has_dynamic_offset: true,
+                min_binding_size: Some(render_group_indirect_size),
+            },
+            count: None,
+        },
+    ];
+
+    if clone {
+        // @binding(2) var<storage, read_write> src_render_group_indirect : RenderGroupIndirect
+        entries.push(BindGroupLayoutEntry {
+            binding: 2,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: false },
+                has_dynamic_offset: true,
+                min_binding_size: Some(render_group_indirect_size),
+            },
+            count: None,
+        });
+    }
+
+    render_device.create_bind_group_layout(label, &entries)
+}
+
+fn create_update_bind_group_layout(
+    render_device: &RenderDevice,
+    label: &str,
+    particle_layout_min_binding_size: NonZero<u64>,
+    property_layout_min_binding_size: Option<NonZero<u64>>,
+) -> BindGroupLayout {
+    let particle_group_size =
+        GpuParticleGroup::aligned_size(render_device.limits().min_storage_buffer_offset_alignment);
+    let mut entries = vec![
+        // @binding(0) var<storage, read_write> particle_buffer : ParticleBuffer
+        BindGroupLayoutEntry {
+            binding: 0,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: false },
+                has_dynamic_offset: false,
+                min_binding_size: Some(particle_layout_min_binding_size),
+            },
+            count: None,
+        },
+        // @binding(1) var<storage, read_write> indirect_buffer : IndirectBuffer
+        BindGroupLayoutEntry {
+            binding: 1,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: false },
+                has_dynamic_offset: false,
+                min_binding_size: BufferSize::new(INDIRECT_INDEX_SIZE as _),
+            },
+            count: None,
+        },
+        // @binding(2) var<storage, read> particle_groups : array<ParticleGroup>
+        BindGroupLayoutEntry {
+            binding: 2,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: true },
+                has_dynamic_offset: false,
+                min_binding_size: Some(particle_group_size),
+            },
+            count: None,
+        },
+    ];
+    if let Some(property_layout_min_binding_size) = property_layout_min_binding_size {
+        // @binding(3) var<storage, read> properties : Properties
+        entries.push(BindGroupLayoutEntry {
+            binding: 3,
+            visibility: ShaderStages::COMPUTE,
+            ty: BindingType::Buffer {
+                ty: BufferBindingType::Storage { read_only: true },
+                has_dynamic_offset: false, // TODO
+                min_binding_size: Some(property_layout_min_binding_size),
+            },
+            count: None,
+        });
+    }
+
+    trace!(
+        "Creating particle bind group layout '{}' for update pass with {} entries.",
+        label,
+        entries.len()
+    );
+    render_device.create_bind_group_layout(label, &entries)
+}
+
 /// Render node to run the simulation sub-graph once per frame.
 ///
 /// This node doesn't simulate anything by itself, but instead schedules the
@@ -3649,133 +3867,269 @@ impl Node for VfxSimulateNode {
         // Compute init pass
         // let mut total_group_count = 0;
         {
-            let mut compute_pass =
-                render_context
-                    .command_encoder()
-                    .begin_compute_pass(&ComputePassDescriptor {
-                        label: Some("hanabi:init"),
-                        timestamp_writes: None,
-                    });
-
             {
                 trace!("loop over effect batches...");
 
                 // Dispatch init compute jobs
                 for (entity, batches) in self.effect_query.iter_manual(world) {
-                    let render_effect_dispatch_buffer_index = batches
-                        .dispatch_buffer_indices
-                        .render_effect_metadata_buffer_index;
-                    let first_render_group_dispatch_buffer_index = &batches
-                        .dispatch_buffer_indices
-                        .first_render_group_dispatch_buffer_index;
-
-                    // FIXME - Currently we unconditionally count all groups because the dispatch
-                    // pass always runs on all groups. We should consider if it's worth skipping
-                    // e.g. dormant or finished effects at the cost of extra complexity.
-                    // total_group_count += batches.group_batches.len() as u32;
+                    for (dest_group_index, initializer) in batches.initializers.iter().enumerate() {
+                        let dest_render_group_dispatch_buffer_index = BufferTableId(
+                            batches
+                                .dispatch_buffer_indices
+                                .first_render_group_dispatch_buffer_index
+                                .0
+                                + dest_group_index as u32,
+                        );
 
-                    let Some(init_pipeline) =
-                        pipeline_cache.get_compute_pipeline(batches.init_pipeline_id)
-                    else {
-                        if let CachedPipelineState::Err(err) =
-                            pipeline_cache.get_compute_pipeline_state(batches.init_pipeline_id)
-                        {
-                            error!(
-                                "Failed to find init pipeline #{} for effect {:?}: {:?}",
-                                batches.init_pipeline_id.id(),
-                                entity,
-                                err
-                            );
+                        // Destination group spawners are packed one after one another.
+                        let spawner_base = batches.spawner_base + dest_group_index as u32;
+                        let spawner_buffer_aligned = effects_meta.spawner_buffer.aligned_size();
+                        assert!(
+                            spawner_buffer_aligned >= GpuSpawnerParams::min_size().get() as usize
+                        );
+                        let spawner_offset = spawner_base * spawner_buffer_aligned as u32;
+
+                        match initializer {
+                            EffectInitializer::Spawner(effect_spawner) => {
+                                let mut compute_pass = render_context
+                                    .command_encoder()
+                                    .begin_compute_pass(&ComputePassDescriptor {
+                                        label: Some("hanabi:init"),
+                                        timestamp_writes: None,
+                                    });
+
+                                let render_effect_dispatch_buffer_index = batches
+                                    .dispatch_buffer_indices
+                                    .render_effect_metadata_buffer_index;
+
+                                // FIXME - Currently we unconditionally count
+                                // all groups because the dispatch pass always
+                                // runs on all groups. We should consider if
+                                // it's worth skipping e.g. dormant or finished
+                                // effects at the cost of extra complexity.
+                                // total_group_count += batches.group_batches.len() as u32;
+
+                                let Some(init_pipeline) = pipeline_cache.get_compute_pipeline(
+                                    batches.init_and_update_pipeline_ids[dest_group_index].init,
+                                ) else {
+                                    if let CachedPipelineState::Err(err) = pipeline_cache
+                                        .get_compute_pipeline_state(
+                                            batches.init_and_update_pipeline_ids[dest_group_index]
+                                                .init,
+                                        )
+                                    {
+                                        error!(
+                                            "Failed to find init pipeline #{} for effect {:?}: \
+                                             {:?}",
+                                            batches.init_and_update_pipeline_ids[dest_group_index]
+                                                .init
+                                                .id(),
+                                            entity,
+                                            err
+                                        );
+                                    }
+                                    continue;
+                                };
+
+                                // Do not dispatch any init work if there's nothing to spawn this frame
+                                let spawn_count = effect_spawner.spawn_count;
+                                if spawn_count == 0 {
+                                    continue;
+                                }
+
+                                const WORKGROUP_SIZE: u32 = 64;
+                                let workgroup_count =
+                                    (spawn_count + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
+
+                                let effect_cache_id = batches.effect_cache_id;
+
+                                // for (effect_entity, effect_slice) in effects_meta.entity_map.iter()
+                                // Retrieve the ExtractedEffect from the entity
+                                // trace!("effect_entity={:?} effect_slice={:?}", effect_entity,
+                                // effect_slice); let effect =
+                                // self.effect_query.get_manual(world, *effect_entity).unwrap();
+
+                                // Get the slice to init
+                                // let effect_slice = effects_meta.get(&effect_entity);
+                                // let effect_group =
+                                //     &effects_meta.effect_cache.buffers()[batch.buffer_index as usize];
+                                let Some(particles_init_bind_group) =
+                                    effect_cache.init_bind_group(effect_cache_id)
+                                else {
+                                    error!(
+                                        "Failed to find init particle buffer bind group for \
+                                         entity {:?}",
+                                        entity
+                                    );
+                                    continue;
+                                };
+
+                                let render_effect_indirect_offset =
+                                    effects_meta.gpu_limits.render_effect_indirect_offset(
+                                        render_effect_dispatch_buffer_index.0,
+                                    );
+
+                                let render_group_indirect_offset =
+                                    effects_meta.gpu_limits.render_group_indirect_offset(
+                                        dest_render_group_dispatch_buffer_index.0,
+                                    );
+
+                                trace!(
+                                    "record commands for init pipeline of effect {:?} \
+                                        (spawn {} = {} workgroups) spawner_base={} \
+                                        spawner_offset={} \
+                                        render_effect_indirect_offset={} \
+                                        first_render_group_indirect_offset={}...",
+                                    batches.handle,
+                                    spawn_count,
+                                    workgroup_count,
+                                    spawner_base,
+                                    spawner_offset,
+                                    render_effect_indirect_offset,
+                                    render_group_indirect_offset,
+                                );
+
+                                // Setup compute pass
+                                compute_pass.set_pipeline(init_pipeline);
+                                compute_pass.set_bind_group(
+                                    0,
+                                    effects_meta.sim_params_bind_group.as_ref().unwrap(),
+                                    &[],
+                                );
+                                compute_pass.set_bind_group(1, particles_init_bind_group, &[]);
+                                compute_pass.set_bind_group(
+                                    2,
+                                    effects_meta.spawner_bind_group.as_ref().unwrap(),
+                                    &[spawner_offset],
+                                );
+                                compute_pass.set_bind_group(
+                                    3,
+                                    effects_meta
+                                        .init_render_indirect_bind_group
+                                        .as_ref()
+                                        .unwrap(),
+                                    &[
+                                        render_effect_indirect_offset as u32,
+                                        render_group_indirect_offset as u32,
+                                        render_group_indirect_offset as u32,
+                                    ],
+                                );
+                                compute_pass.dispatch_workgroups(workgroup_count, 1, 1);
+                                trace!("init compute dispatched");
+                            }
+
+                            EffectInitializer::Cloner(EffectCloner {
+                                spawn_this_frame, ..
+                            }) => {
+                                if !spawn_this_frame {
+                                    continue;
+                                }
+
+                                let mut compute_pass = render_context
+                                    .command_encoder()
+                                    .begin_compute_pass(&ComputePassDescriptor {
+                                        label: Some("hanabi:clone"),
+                                        timestamp_writes: None,
+                                    });
+
+                                let clone_pipeline_id =
+                                    batches.init_and_update_pipeline_ids[dest_group_index].init;
+
+                                let effect_cache_id = batches.effect_cache_id;
+
+                                let Some(clone_pipeline) =
+                                    pipeline_cache.get_compute_pipeline(clone_pipeline_id)
+                                else {
+                                    if let CachedPipelineState::Err(err) =
+                                        pipeline_cache.get_compute_pipeline_state(clone_pipeline_id)
+                                    {
+                                        error!(
+                                            "Failed to find clone pipeline #{} for effect \
+                                                    {:?}: {:?}",
+                                            clone_pipeline_id.id(),
+                                            entity,
+                                            err
+                                        );
+                                    }
+                                    continue;
+                                };
+
+                                let Some(particles_init_bind_group) =
+                                    effect_cache.init_bind_group(effect_cache_id)
+                                else {
+                                    error!(
+                                        "Failed to find clone particle buffer bind group \
+                                                 for entity {:?}, effect cache ID {:?}",
+                                        entity, effect_cache_id
+                                    );
+                                    continue;
+                                };
+
+                                let render_effect_dispatch_buffer_index = batches
+                                    .dispatch_buffer_indices
+                                    .render_effect_metadata_buffer_index;
+                                let clone_dest_render_group_dispatch_buffer_index = batches
+                                    .dispatch_buffer_indices
+                                    .trail_dispatch_buffer_indices
+                                    [&(dest_group_index as u32)]
+                                    .dest;
+                                let clone_src_render_group_dispatch_buffer_index = batches
+                                    .dispatch_buffer_indices
+                                    .trail_dispatch_buffer_indices
+                                    [&(dest_group_index as u32)]
+                                    .src;
+
+                                let render_effect_indirect_offset =
+                                    effects_meta.gpu_limits.render_effect_indirect_offset(
+                                        render_effect_dispatch_buffer_index.0,
+                                    );
+
+                                let clone_dest_render_group_indirect_offset =
+                                    effects_meta.gpu_limits.render_group_indirect_offset(
+                                        clone_dest_render_group_dispatch_buffer_index.0,
+                                    );
+                                let clone_src_render_group_indirect_offset =
+                                    effects_meta.gpu_limits.render_group_indirect_offset(
+                                        clone_src_render_group_dispatch_buffer_index.0,
+                                    );
+
+                                compute_pass.set_pipeline(clone_pipeline);
+                                compute_pass.set_bind_group(
+                                    0,
+                                    effects_meta.sim_params_bind_group.as_ref().unwrap(),
+                                    &[],
+                                );
+                                compute_pass.set_bind_group(1, particles_init_bind_group, &[]);
+                                compute_pass.set_bind_group(
+                                    2,
+                                    effects_meta.spawner_bind_group.as_ref().unwrap(),
+                                    &[spawner_offset],
+                                );
+                                compute_pass.set_bind_group(
+                                    3,
+                                    effects_meta
+                                        .init_render_indirect_bind_group
+                                        .as_ref()
+                                        .unwrap(),
+                                    &[
+                                        render_effect_indirect_offset as u32,
+                                        clone_dest_render_group_indirect_offset as u32,
+                                        clone_src_render_group_indirect_offset as u32,
+                                    ],
+                                );
+
+                                if let Some(dispatch_indirect_buffer) =
+                                    effects_meta.dispatch_indirect_buffer.buffer()
+                                {
+                                    compute_pass.dispatch_workgroups_indirect(
+                                        dispatch_indirect_buffer,
+                                        clone_src_render_group_indirect_offset,
+                                    );
+                                }
+                                trace!("clone compute dispatched");
+                            }
                         }
-                        continue;
-                    };
-
-                    // Do not dispatch any init work if there's nothing to spawn this frame
-                    let spawn_count = batches.spawn_count;
-                    if spawn_count == 0 {
-                        continue;
                     }
-
-                    const WORKGROUP_SIZE: u32 = 64;
-                    let workgroup_count = (spawn_count + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
-
-                    let effect_cache_id = batches.effect_cache_id;
-
-                    // for (effect_entity, effect_slice) in effects_meta.entity_map.iter() {
-                    // Retrieve the ExtractedEffect from the entity
-                    // trace!("effect_entity={:?} effect_slice={:?}", effect_entity,
-                    // effect_slice); let effect =
-                    // self.effect_query.get_manual(world, *effect_entity).unwrap();
-
-                    // Get the slice to init
-                    // let effect_slice = effects_meta.get(&effect_entity);
-                    // let effect_group =
-                    //     &effects_meta.effect_cache.buffers()[batch.buffer_index as usize];
-                    let Some(particles_init_bind_group) =
-                        effect_cache.init_bind_group(effect_cache_id)
-                    else {
-                        error!(
-                            "Failed to find init particle buffer bind group for entity {:?}",
-                            entity
-                        );
-                        continue;
-                    };
-
-                    let spawner_base = batches.spawner_base;
-
-                    let spawner_buffer_aligned = effects_meta.spawner_buffer.aligned_size();
-                    assert!(spawner_buffer_aligned >= GpuSpawnerParams::min_size().get() as usize);
-                    let spawner_offset = spawner_base * spawner_buffer_aligned as u32;
-
-                    let render_effect_indirect_offset = effects_meta
-                        .gpu_limits
-                        .render_effect_indirect_offset(render_effect_dispatch_buffer_index.0);
-
-                    let first_render_group_indirect_offset = effects_meta
-                        .gpu_limits
-                        .render_group_indirect_offset(first_render_group_dispatch_buffer_index.0);
-
-                    trace!(
-                        "record commands for init pipeline of effect {:?} \
-                            (spawn {} = {} workgroups) spawner_base={} \
-                            spawner_offset={} \
-                            render_effect_indirect_offset={} \
-                            first_render_group_indirect_offset={}...",
-                        batches.handle,
-                        spawn_count,
-                        workgroup_count,
-                        spawner_base,
-                        spawner_offset,
-                        render_effect_indirect_offset,
-                        first_render_group_indirect_offset,
-                    );
-
-                    // Setup compute pass
-                    compute_pass.set_pipeline(init_pipeline);
-                    compute_pass.set_bind_group(
-                        0,
-                        effects_meta.sim_params_bind_group.as_ref().unwrap(),
-                        &[],
-                    );
-                    compute_pass.set_bind_group(1, particles_init_bind_group, &[]);
-                    compute_pass.set_bind_group(
-                        2,
-                        effects_meta.spawner_bind_group.as_ref().unwrap(),
-                        &[spawner_offset],
-                    );
-                    compute_pass.set_bind_group(
-                        3,
-                        effects_meta
-                            .init_render_indirect_bind_group
-                            .as_ref()
-                            .unwrap(),
-                        &[
-                            render_effect_indirect_offset as u32,
-                            first_render_group_indirect_offset as u32,
-                        ],
-                    );
-                    compute_pass.dispatch_workgroups(workgroup_count, 1, 1);
-                    trace!("init compute dispatched");
                 }
             }
         }
@@ -3857,11 +4211,6 @@ impl Node for VfxSimulateNode {
                     .dispatch_buffer_indices
                     .first_update_group_dispatch_buffer_index;
 
-                let spawner_base = batches.spawner_base;
-
-                let spawner_buffer_aligned = effects_meta.spawner_buffer.aligned_size();
-                assert!(spawner_buffer_aligned >= GpuSpawnerParams::min_size().get() as usize);
-
                 let Some(update_render_indirect_bind_group) = &effect_bind_groups
                     .update_render_indirect_bind_groups
                     .get(&effect_cache_id)
@@ -3877,18 +4226,18 @@ impl Node for VfxSimulateNode {
                     continue;
                 };
 
-                for (group_index, update_pipeline_id) in
-                    batches.update_pipeline_ids.iter().enumerate()
+                for (group_index, init_and_update_pipeline_id) in
+                    batches.init_and_update_pipeline_ids.iter().enumerate()
                 {
                     let Some(update_pipeline) =
-                        pipeline_cache.get_compute_pipeline(*update_pipeline_id)
+                        pipeline_cache.get_compute_pipeline(init_and_update_pipeline_id.update)
                     else {
-                        if let CachedPipelineState::Err(err) =
-                            pipeline_cache.get_compute_pipeline_state(*update_pipeline_id)
+                        if let CachedPipelineState::Err(err) = pipeline_cache
+                            .get_compute_pipeline_state(init_and_update_pipeline_id.update)
                         {
                             error!(
                                 "Failed to find update pipeline #{} for effect {:?}, group {}: {:?}",
-                                update_pipeline_id.id(),
+                                init_and_update_pipeline_id.update.id(),
                                 entity,
                                 group_index,
                                 err
@@ -3902,7 +4251,13 @@ impl Node for VfxSimulateNode {
                             first_update_group_dispatch_buffer_index.0 + group_index as u32,
                         );
 
-                    // for (effect_entity, effect_slice) in effects_meta.entity_map.iter() {
+                    // Destination group spawners are packed one after one another.
+                    let spawner_base = batches.spawner_base + group_index as u32;
+                    let spawner_buffer_aligned = effects_meta.spawner_buffer.aligned_size();
+                    assert!(spawner_buffer_aligned >= GpuSpawnerParams::min_size().get() as usize);
+                    let spawner_offset = spawner_base * spawner_buffer_aligned as u32;
+
+                    // for (effect_entity, effect_slice) in effects_meta.entity_map.iter()
                     // Retrieve the ExtractedEffect from the entity
                     // trace!("effect_entity={:?} effect_slice={:?}", effect_entity,
                     // effect_slice); let effect =
@@ -3933,7 +4288,7 @@ impl Node for VfxSimulateNode {
                     compute_pass.set_bind_group(
                         2,
                         effects_meta.spawner_bind_group.as_ref().unwrap(),
-                        &[spawner_base * spawner_buffer_aligned as u32],
+                        &[spawner_offset],
                     );
                     compute_pass.set_bind_group(3, update_render_indirect_bind_group, &[]);
 
diff --git a/src/render/vfx_common.wgsl b/src/render/vfx_common.wgsl
index b1f32657..2f28a2f6 100644
--- a/src/render/vfx_common.wgsl
+++ b/src/render/vfx_common.wgsl
@@ -29,6 +29,9 @@ struct Spawner {
     count: atomic<i32>,
 #endif
     effect_index: u32,
+    // The lifetime to initialize particles with. This is only used for cloners
+    // (i.e. trails or ribbons).
+    lifetime: f32,
 #ifdef SPAWNER_PADDING
     {{SPAWNER_PADDING}}
 #endif
@@ -83,8 +86,7 @@ struct DispatchIndirect {
 // as a raw array<u32>, so that we can avoid WGSL struct padding and keep data
 // more compact in the render indirect buffer. Each offset corresponds to a field
 // in the RenderIndirect struct.
-const REM_OFFSET_MAX_SPAWN: u32 = 0u;
-const REM_OFFSET_PING: u32 = 1u;
+const REM_OFFSET_PING: u32 = 0u;
 
 const RGI_OFFSET_VERTEX_COUNT: u32 = 0u;
 const RGI_OFFSET_INSTANCE_COUNT: u32 = 1u;
@@ -93,17 +95,9 @@ const RGI_OFFSET_BASE_INSTANCE: u32 = 3u;
 const RGI_OFFSET_ALIVE_COUNT: u32 = 4u;
 const RGI_OFFSET_MAX_UPDATE: u32 = 5u;
 const RGI_OFFSET_DEAD_COUNT: u32 = 6u;
+const RGI_OFFSET_MAX_SPAWN: u32 = 7u;
 
 struct RenderEffectMetadata {
-    /// Maxmimum number of init threads to run on next frame. This is cached from
-    /// `dead_count` during the indirect dispatch of the previous frame, so that the
-    /// init compute pass can cap its thread count while also decrementing the actual
-    /// `dead_count` as particles are spawned.
-#ifdef REM_MAX_SPAWN_ATOMIC
-    max_spawn: atomic<u32>,
-#else
-    max_spawn: u32,
-#endif
     /// Index of the ping buffer for particle indices. Init and update compute passes
     /// always write into the ping buffer and read from the pong buffer. The buffers
     /// are swapped during the indirect dispatch.
@@ -133,6 +127,7 @@ struct RenderGroupIndirect {
     /// Number of dead particles, decremented during the init pass as new particles
     /// are spawned, and incremented during the update pass as existing particles die.
     dead_count: atomic<u32>,
+    max_spawn: atomic<u32>,
     {{RENDER_GROUP_INDIRECT_PADDING}}
 }
 
diff --git a/src/render/vfx_indirect.wgsl b/src/render/vfx_indirect.wgsl
index 6aab27a9..111cc6d3 100644
--- a/src/render/vfx_indirect.wgsl
+++ b/src/render/vfx_indirect.wgsl
@@ -2,7 +2,8 @@
     ParticleGroup, SimParams, Spawner,
     DI_OFFSET_X, DI_OFFSET_PONG,
     RGI_OFFSET_ALIVE_COUNT, RGI_OFFSET_MAX_UPDATE, RGI_OFFSET_DEAD_COUNT,
-    REM_OFFSET_MAX_SPAWN, RGI_OFFSET_INSTANCE_COUNT, REM_OFFSET_PING
+    REM_OFFSET_MAX_CLONE, RGI_OFFSET_MAX_SPAWN,
+    RGI_OFFSET_INSTANCE_COUNT, REM_OFFSET_PING
 }
 
 const RENDER_EFFECT_INDIRECT_STRIDE: u32 = {{RENDER_EFFECT_INDIRECT_STRIDE}} / 4u;
@@ -13,6 +14,7 @@ const DISPATCH_INDIRECT_STRIDE: u32 = {{DISPATCH_INDIRECT_STRIDE}} / 4u;
 @group(0) @binding(1) var<storage, read_write> render_group_indirect_buffer : array<u32>;
 @group(0) @binding(2) var<storage, read_write> dispatch_indirect_buffer : array<u32>;
 @group(0) @binding(3) var<storage, read> group_buffer : array<ParticleGroup>;
+@group(0) @binding(4) var<storage, read> spawner_buffer : array<Spawner>;
 @group(1) @binding(0) var<uniform> sim_params : SimParams;
 
 /// Calculate the indirect workgroups counts based on the number of particles alive.
@@ -38,7 +40,10 @@ fn main(@builtin(global_invocation_id) global_invocation_id: vec3<u32>) {
     // Retrieve the effect index from the spawner table
     let group_index = group_buffer[index].group_index;
     let effect_index = group_buffer[index].effect_index;
-    let is_first_group = group_buffer[index].index_in_effect == 0u;
+
+    let rem_base = RENDER_EFFECT_INDIRECT_STRIDE * effect_index;
+    let group_index_in_effect = group_buffer[index].index_in_effect;
+    let is_first_group = group_index_in_effect == 0u;
 
     // Calculate the base offset (in number of u32 items) into the render indirect and
     // dispatch indirect arrays.
@@ -49,10 +54,12 @@ fn main(@builtin(global_invocation_id) global_invocation_id: vec3<u32>) {
     // with the particles actually alive at the end of their update (after aged).
     render_group_indirect_buffer[rgi_base + RGI_OFFSET_INSTANCE_COUNT] = 0u;
 
+    let alive_count = render_group_indirect_buffer[rgi_base + RGI_OFFSET_ALIVE_COUNT];
+    let dead_count = render_group_indirect_buffer[rgi_base + RGI_OFFSET_DEAD_COUNT];
+
     // Calculate the number of thread groups to dispatch for the update
     // pass, which is the number of alive particles rounded up to 64
     // (workgroup_size).
-    let alive_count = render_group_indirect_buffer[rgi_base + RGI_OFFSET_ALIVE_COUNT];
     dispatch_indirect_buffer[di_base + DI_OFFSET_X] = (alive_count + 63u) >> 6u;
 
     // Update max_update from current value of alive_count, so that the
@@ -60,17 +67,14 @@ fn main(@builtin(global_invocation_id) global_invocation_id: vec3<u32>) {
     // atomically modifying alive_count itself for next frame.
     render_group_indirect_buffer[rgi_base + RGI_OFFSET_MAX_UPDATE] = alive_count;
 
-    if (is_first_group) {
-        let rem_base = RENDER_EFFECT_INDIRECT_STRIDE * effect_index;
-
-        // Copy the number of dead particles to a constant location, so that the
-        // init pass on next frame can atomically modify dead_count in parallel
-        // yet still read its initial value at the beginning of the init pass,
-        // and limit the number of particles spawned to the number of dead
-        // particles to recycle.
-        let dead_count = render_group_indirect_buffer[rgi_base + RGI_OFFSET_DEAD_COUNT];
-        render_effect_indirect_buffer[rem_base + REM_OFFSET_MAX_SPAWN] = dead_count;
+    // Copy the number of dead particles to a constant location, so that the
+    // init pass on next frame can atomically modify dead_count in parallel
+    // yet still read its initial value at the beginning of the init pass,
+    // and limit the number of particles spawned to the number of dead
+    // particles to recycle.
+    render_group_indirect_buffer[rgi_base + RGI_OFFSET_MAX_SPAWN] = dead_count;
 
+    if (is_first_group) {
         // Swap ping/pong buffers
         let ping = render_effect_indirect_buffer[rem_base + REM_OFFSET_PING];
         let pong = 1u - ping;
diff --git a/src/render/vfx_init.wgsl b/src/render/vfx_init.wgsl
index 4aa8a69e..0fad7de1 100644
--- a/src/render/vfx_init.wgsl
+++ b/src/render/vfx_init.wgsl
@@ -1,82 +1,127 @@
-#import bevy_hanabi::vfx_common::{
-    IndirectBuffer, ParticleGroup, RenderEffectMetadata, RenderGroupIndirect, SimParams, Spawner,
-    seed, tau, pcg_hash, to_float01, frand, frand2, frand3, frand4,
-    rand_uniform_f, rand_uniform_vec2, rand_uniform_vec3, rand_uniform_vec4,
-    rand_normal_f, rand_normal_vec2, rand_normal_vec3, rand_normal_vec4, proj
-}
-
-struct Particle {
-{{ATTRIBUTES}}
-}
-
-struct ParticleBuffer {
-    particles: array<Particle>,
-}
-
-{{PROPERTIES}}
-
-@group(0) @binding(0) var<uniform> sim_params : SimParams;
-@group(1) @binding(0) var<storage, read_write> particle_buffer : ParticleBuffer;
-@group(1) @binding(1) var<storage, read_write> indirect_buffer : IndirectBuffer;
-@group(1) @binding(2) var<storage, read> particle_groups : array<ParticleGroup>;
-{{PROPERTIES_BINDING}}
-@group(2) @binding(0) var<storage, read_write> spawner : Spawner; // NOTE - same group as update
-@group(3) @binding(0) var<storage, read_write> render_effect_indirect : RenderEffectMetadata;
-@group(3) @binding(1) var<storage, read_write> render_group_indirect : RenderGroupIndirect;
-
-{{INIT_EXTRA}}
-
-@compute @workgroup_size(64)
-fn main(@builtin(global_invocation_id) global_invocation_id: vec3<u32>) {
-    var index = global_invocation_id.x;
-
-    // Cap to max number of dead particles, copied from dead_count at the end of the
-    // previous iteration, and constant during this pass (unlike dead_count).
-    if (index >= render_effect_indirect.max_spawn) {
-        return;
-    }
-
-    // Cap to the actual number of spawning requested by CPU, since compute shaders run
-    // in workgroup_size(64) so more threads than needed are launched (rounded up to 64).
-    let spawn_count : u32 = u32(spawner.spawn);
-    if (index >= spawn_count) {
-        return;
-    }
-
-    // Recycle a dead particle from the first group
-    let base_index = particle_groups[0].effect_particle_offset;
-    let dead_index = atomicSub(&render_group_indirect.dead_count, 1u) - 1u;
-    index = indirect_buffer.indices[3u * (base_index + dead_index) + 2u];
-
-    // Update PRNG seed
-    seed = pcg_hash(index ^ spawner.seed);
-
-    // Spawner transform
-    let transform = transpose(
-        mat4x4(
-            spawner.transform[0],
-            spawner.transform[1],
-            spawner.transform[2],
-            vec4<f32>(0.0, 0.0, 0.0, 1.0)
-        )
-    );
-
-    // Initialize new particle
-    var particle = Particle();
-    {{INIT_CODE}}
-
-    {{SIMULATION_SPACE_TRANSFORM_PARTICLE}}
-
-    // Count as alive
-    atomicAdd(&render_group_indirect.alive_count, 1u);
-
-    // Always write into ping, read from pong
-    let ping = render_effect_indirect.ping;
-
-    // Add to alive list
-    let indirect_index = atomicAdd(&render_group_indirect.instance_count, 1u);
-    indirect_buffer.indices[3u * (base_index + indirect_index) + ping] = index;
-
-    // Write back spawned particle
-    particle_buffer.particles[index] = particle;
-}
+#import bevy_hanabi::vfx_common::{
+    IndirectBuffer, ParticleGroup, RenderEffectMetadata, RenderGroupIndirect, SimParams, Spawner,
+    seed, tau, pcg_hash, to_float01, frand, frand2, frand3, frand4,
+    rand_uniform_f, rand_uniform_vec2, rand_uniform_vec3, rand_uniform_vec4,
+    rand_normal_f, rand_normal_vec2, rand_normal_vec3, rand_normal_vec4, proj
+}
+
+struct Particle {
+{{ATTRIBUTES}}
+}
+
+struct ParticleBuffer {
+    particles: array<Particle>,
+}
+
+{{PROPERTIES}}
+
+@group(0) @binding(0) var<uniform> sim_params: SimParams;
+@group(1) @binding(0) var<storage, read_write> particle_buffer: ParticleBuffer;
+@group(1) @binding(1) var<storage, read_write> indirect_buffer: IndirectBuffer;
+@group(1) @binding(2) var<storage, read> particle_groups: array<ParticleGroup>;
+{{PROPERTIES_BINDING}}
+
+@group(2) @binding(0) var<storage, read_write> spawner: Spawner; // NOTE - same group as update
+@group(3) @binding(0) var<storage, read_write> render_effect_indirect: RenderEffectMetadata;
+@group(3) @binding(1) var<storage, read_write> dest_render_group_indirect: RenderGroupIndirect;
+@group(3) @binding(2) var<storage, read_write> src_render_group_indirect: RenderGroupIndirect;
+
+{{INIT_EXTRA}}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) global_invocation_id: vec3<u32>) {
+    let thread_index = global_invocation_id.x;
+
+    // Cap to max number of dead particles, copied from dead_count at the end of the
+    // previous iteration, and constant during this pass (unlike dead_count).
+    let max_spawn = atomicLoad(&dest_render_group_indirect.max_spawn);
+    if (thread_index >= max_spawn) {
+        return;
+    }
+
+    // Cap to the actual number of spawning requested by CPU (in the case of
+    // spawners) or the number of particles present in the source group (in the
+    // case of cloners), since compute shaders run in workgroup_size(64) so more
+    // threads than needed are launched (rounded up to 64).
+#ifdef CLONE
+    // FIXME: This doesn't actually need to be atomic.
+    let spawn_count: u32 = atomicLoad(&src_render_group_indirect.alive_count);
+#else   // CLONE
+    let spawn_count: u32 = u32(spawner.spawn);
+#endif  // CLONE
+    if (thread_index >= spawn_count) {
+        return;
+    }
+
+    // Always write into ping, read from pong
+    let ping = render_effect_indirect.ping;
+    let pong = 1u - ping;
+
+#ifdef CLONE
+    let src_base_index = particle_groups[{{SRC_GROUP_INDEX}}].effect_particle_offset +
+        particle_groups[{{SRC_GROUP_INDEX}}].indirect_index;
+    let src_index = indirect_buffer.indices[3u * (src_base_index + thread_index) + ping];
+#endif  // CLONE
+
+    // Recycle a dead particle from the destination group
+    var dest_base_index = particle_groups[{{DEST_GROUP_INDEX}}].effect_particle_offset +
+        particle_groups[{{DEST_GROUP_INDEX}}].indirect_index;
+    let dest_dead_index = atomicSub(&dest_render_group_indirect.dead_count, 1u) - 1u;
+    let dest_index = indirect_buffer.indices[3u * (dest_base_index + dest_dead_index) + 2u];
+
+    seed = pcg_hash(dest_index ^ spawner.seed);
+
+#ifdef CLONE
+    var particle: Particle = particle_buffer.particles[src_index];
+    {{INIT_CODE}}
+
+    // For trails and ribbons, age and lifetime are managed automatically.
+    particle.age = 0.0;
+    particle.lifetime = spawner.lifetime;
+#ifdef ATTRIBUTE_PREV
+#ifdef ATTRIBUTE_NEXT
+    let prev = particle.prev;
+    let next = src_index;
+    particle_buffer.particles[next].prev = dest_index;
+    if (prev != 0xffffffffu) {
+        particle_buffer.particles[prev].next = dest_index;
+    }
+    particle.next = src_index;
+    particle.prev = prev;
+#endif  // ATTRIBUTE_NEXT
+#endif  // ATTRIBUTE_PREV
+#else   // CLONE
+    // Spawner transform
+    let transform = transpose(
+        mat4x4(
+            spawner.transform[0],
+            spawner.transform[1],
+            spawner.transform[2],
+            vec4<f32>(0.0, 0.0, 0.0, 1.0)
+        )
+    );
+
+    // Initialize new particle
+    var particle = Particle();
+    {{INIT_CODE}}
+
+#ifdef ATTRIBUTE_NEXT
+    particle.next = 0xffffffffu;
+#endif  // ATTRIBUTE_NEXT
+#ifdef ATTRIBUTE_PREV
+    particle.prev = 0xffffffffu;
+#endif  // ATTRIBUTE_PREV
+
+    {{SIMULATION_SPACE_TRANSFORM_PARTICLE}}
+#endif  // CLONE
+
+    // Count as alive
+    atomicAdd(&dest_render_group_indirect.alive_count, 1u);
+
+    // Add to alive list
+    let dest_indirect_index = atomicAdd(&dest_render_group_indirect.instance_count, 1u);
+    indirect_buffer.indices[3u * (dest_base_index + dest_indirect_index) + ping] = dest_index;
+
+    // Write back new particle
+    particle_buffer.particles[dest_index] = particle;
+}
diff --git a/src/render/vfx_render.wgsl b/src/render/vfx_render.wgsl
index ef1dd778..3d43d86c 100644
--- a/src/render/vfx_render.wgsl
+++ b/src/render/vfx_render.wgsl
@@ -129,6 +129,24 @@ fn vertex(
 
 {{VERTEX_MODIFIERS}}
 
+#ifdef RIBBONS
+    let next_index = particle.next;
+    if (next_index >= arrayLength(&particle_buffer.particles)) {
+        out.position = vec4(0.0);
+        return out;
+    }
+
+    let next_particle = particle_buffer.particles[next_index];
+    var delta = next_particle.position - particle.position;
+
+    axis_x = normalize(delta);
+    axis_y = normalize(cross(axis_x, axis_z));
+    axis_z = cross(axis_x, axis_y);
+
+    position = mix(next_particle.position, particle.position, 0.5);
+    size = vec2(length(delta), size.y);
+#endif  // RIBBONS
+
     // Expand particle mesh vertex based on particle position ("origin"), and local
     // orientation and size of the particle mesh (currently: only quad).
     let vpos = vertex_position * vec3<f32>(size.x, size.y, 1.0);
diff --git a/src/render/vfx_update.wgsl b/src/render/vfx_update.wgsl
index 0f0ecd23..d43a1cdb 100644
--- a/src/render/vfx_update.wgsl
+++ b/src/render/vfx_update.wgsl
@@ -30,13 +30,6 @@ struct ParticleBuffer {
 fn main(@builtin(global_invocation_id) global_invocation_id: vec3<u32>) {
     let thread_index = global_invocation_id.x;
 
-    // Cap at maximum number of particles.
-    // FIXME - This is probably useless given below cap
-    let max_particles : u32 = particle_groups[{{GROUP_INDEX}}].capacity;
-    if (thread_index >= max_particles) {
-        return;
-    }
-
     // Cap at maximum number of alive particles.
     if (thread_index >= render_group_indirect[{{GROUP_INDEX}}].max_update) {
         return;
@@ -59,16 +52,37 @@ fn main(@builtin(global_invocation_id) global_invocation_id: vec3<u32>) {
     {{UPDATE_CODE}}
     {{REAP_CODE}}
 
-    particle_buffer.particles[index] = particle;
+    {{WRITEBACK_CODE}}
 
     // Check if alive
     if (!is_alive) {
+#ifdef ATTRIBUTE_PREV
+#ifdef ATTRIBUTE_NEXT
+#ifdef TRAIL
+        // We know that no particles behind us (including our previous) are
+        // going to be alive after this. So we can just set the next particle's
+        // prev pointer to null.
+        let next = particle_buffer.particles[index].next;
+        if (next != 0xffffffffu) {
+            particle_buffer.particles[next].prev = 0xffffffffu;
+        }
+#else   // TRAIL
+        // There's no worry about races here, because the trails are all in a
+        // different group.
+        let prev = particle_buffer.particles[index].prev;
+        if (prev != 0xffffffffu) {
+            particle_buffer.particles[prev].next = 0xffffffffu;
+        }
+#endif  // TRAIL
+#endif  // ATTRIBUTE_NEXT
+#endif  // ATTRIBUTE_PREV
+
         // Save dead index
         let dead_index = atomicAdd(&render_group_indirect[{{GROUP_INDEX}}].dead_count, 1u);
         indirect_buffer.indices[3u * (base_index + dead_index) + 2u] = index;
         // Also increment copy of dead count, which was updated in dispatch indirect
         // pass just before, and need to remain correct after this pass
-        atomicAdd(&render_effect_indirect.max_spawn, 1u);
+        atomicAdd(&render_group_indirect[{{GROUP_INDEX}}].max_spawn, 1u);
         atomicSub(&render_group_indirect[{{GROUP_INDEX}}].alive_count, 1u);
     } else {
         // Increment alive particle count and write indirection index for later rendering
diff --git a/src/spawn.rs b/src/spawn.rs
index f094e272..8afc5df4 100644
--- a/src/spawn.rs
+++ b/src/spawn.rs
@@ -143,6 +143,37 @@ impl<T: Copy + FromReflect + FloatHash> Hash for CpuValue<T> {
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Debug, Reflect, Serialize, Deserialize)]
+#[reflect(Serialize, Deserialize)]
+pub enum Initializer {
+    Spawner(Spawner),
+    Cloner(Cloner),
+}
+
+impl From<Spawner> for Initializer {
+    #[inline]
+    fn from(value: Spawner) -> Self {
+        Self::Spawner(value)
+    }
+}
+
+impl From<Cloner> for Initializer {
+    #[inline]
+    fn from(value: Cloner) -> Self {
+        Self::Cloner(value)
+    }
+}
+
+impl Initializer {
+    #[cfg(test)]
+    fn get_spawner(&self) -> Option<&Spawner> {
+        match *self {
+            Initializer::Spawner(ref spawner) => Some(spawner),
+            Initializer::Cloner(_) => None,
+        }
+    }
+}
+
 /// Spawner defining how new particles are emitted.
 ///
 /// The spawner defines how new particles are emitted and when. Each time the
@@ -152,11 +183,11 @@ impl<T: Copy + FromReflect + FloatHash> Hash for CpuValue<T> {
 /// spawn is stored as a floating-point number, and any remainder accumulates
 /// for the next emitting.
 ///
-/// The spawner itself is embedded into the [`EffectSpawner`] component. Once
-/// per frame the [`tick_spawners()`] system will add the component if it's
-/// missing, cloning the [`Spawner`] from the source [`EffectAsset`], then tick
-/// the [`Spawner`] stored in the [`EffectSpawner`].
-#[derive(Debug, Copy, Clone, PartialEq, Reflect, Serialize, Deserialize)]
+/// The spawner itself is embedded into the [`EffectInitializers`] component.
+/// Once per frame the [`tick_spawners()`] system will add the component if
+/// it's missing, cloning the [`Spawner`] from the source [`EffectAsset`], then
+/// tick the [`Spawner`] stored in the [`EffectInitializers`].
+#[derive(Debug, Clone, Copy, PartialEq, Reflect, Serialize, Deserialize)]
 #[reflect(Default)]
 pub struct Spawner {
     /// Number of particles to spawn over [`spawn_time`].
@@ -172,7 +203,7 @@ pub struct Spawner {
     /// If this is `spawn_time`, the system spawns a steady stream of particles.
     period: CpuValue<f32>,
 
-    /// Whether the system is active at startup. The value is used to initialize
+    /// Whether the spawner is active at startup. The value is used to initialize
     /// [`EffectSpawner::active`].
     ///
     /// [`EffectSpawner::active`]: crate::EffectSpawner::active
@@ -412,24 +443,184 @@ impl Spawner {
     }
 }
 
-/// Runtime component maintaining the state of the spawner for an effect.
+/// Defines how particle trails are to be constructed.
+///
+/// Particle trails are constructed by cloning the particles from a group into
+/// a different group on a fixed interval. Each time the cloner ticks, it
+/// clones all the particles from the source group into the destination group.
+/// Hanabi then runs the initialization modifiers on the newly-cloned
+/// particles. Particle clones that would overflow the destination group
+/// (exceed its capacity) are dropped.
+///
+/// The cloner itself is embedded into the [`EffectInitializers`] component.
+/// Once per frame the [`tick_spawners()`] system will add the component if
+/// it's missing, copying fields from the [`Cloner`] to the [`EffectCloner`].
+#[derive(Default, Clone, Copy, Debug, PartialEq, Reflect, Serialize, Deserialize)]
+#[reflect(Serialize, Deserialize)]
+pub struct Cloner {
+    /// The group from which the cloner copies.
+    pub src_group_index: u32,
+
+    /// Time between clone operations, in seconds.
+    pub period: CpuValue<f32>,
+
+    /// Time that the particles persist, in seconds.
+    ///
+    /// Unlike spawned particles, cloned particles don't use the
+    /// [`crate::attributes::Attribute::LIFETIME`] attribute and instead track
+    /// lifetime themselves, using this value. This is because, internally,
+    /// their lifetimes must follow last-in-first-out (LIFO) order.
+    pub lifetime: f32,
+
+    /// Whether the system is active at startup. The value is used to initialize
+    /// [`EffectCloner::active`].
+    ///
+    /// [`EffectCloner::active`]: crate::EffectCloner::active
+    pub starts_active: bool,
+}
+
+impl Cloner {
+    /// Creates a cloner with the given source group index, period, and lifetime.
+    ///
+    /// This is the raw constructor. A more convenient way to create cloners is
+    /// to use [`EffectAsset::with_trails`] or [`EffectAsset::with_ribbons`].
+    pub fn new(src_group_index: u32, period: impl Into<CpuValue<f32>>, lifetime: f32) -> Self {
+        Self {
+            src_group_index,
+            period: period.into(),
+            lifetime,
+            starts_active: true,
+        }
+    }
+
+    /// Sets whether the cloner starts active when the effect is instantiated.
+    ///
+    /// This value will be transfered to the active state of the
+    /// [`EffectCloner`] once it's instantiated. Inactive cloners do not clone
+    /// any particle.
+    pub fn with_starts_active(mut self, starts_active: bool) -> Self {
+        self.starts_active = starts_active;
+        self
+    }
+
+    /// Set whether the cloner starts active when the effect is instantiated.
+    ///
+    /// This value will be transfered to the active state of the
+    /// [`EffectCloner`] once it's instantiated. Inactive cloners do not clone
+    /// any particle.
+    pub fn set_starts_active(&mut self, starts_active: bool) {
+        self.starts_active = starts_active;
+    }
+
+    /// Get whether the cloner starts active when the effect is instantiated.
+    ///
+    /// This value will be transfered to the active state of the
+    /// [`EffectCloner`] once it's instantiated. Inactive cloners do not clone
+    /// any particle.
+    pub fn starts_active(&self) -> bool {
+        self.starts_active
+    }
+}
+
+/// A runtime component maintaining the state of all initializers for an effect.
 ///
 /// This component is automatically added to the same [`Entity`] as the
 /// [`ParticleEffect`] it's associated with, during [`tick_spawners()`], if not
-/// already present on the entity. In that case, the spawner configuration is
-/// cloned from the underlying [`EffectAsset`] associated with the particle
+/// already present on the entity. In that case, the initializer configurations
+/// are cloned from the underlying [`EffectAsset`] associated with the particle
 /// effect instance.
 ///
-/// You can manually add this component in advance to override its [`Spawner`].
-/// In that case [`tick_spawners()`] will use the existing component you added.
+/// You can manually add this component in advance to override its [`Spawner`]s
+/// and/or [`Cloner`]s. In that case [`tick_spawners()`] will use the existing
+/// component you added.
 ///
-/// Each frame, the component will automatically calculate the number of
-/// particles to spawn, via its internal [`Spawner`], and store it into
-/// [`spawn_count`]. You can manually override that value if you want, to create
-/// more complex spawning sequences.
+/// Each frame, for spawners, the component will automatically calculate the
+/// number of particles to spawn, via its internal [`Spawner`], and store it
+/// into [`spawn_count`]. You can manually override that value if you want, to
+/// create more complex spawning sequences. For cloners, the component sets the
+/// [`spawn_this_frame`] flag as appropriate. You can likewise manually override
+/// that value if you want in order to clone on different schedules.
 ///
 /// [`spawn_count`]: crate::EffectSpawner::spawn_count
-#[derive(Default, Clone, Copy, PartialEq, Component)]
+/// [`spawn_count`]: crate::EffectCloner::spawn_this_frame
+#[derive(Default, Clone, Component, PartialEq, Reflect, Debug, Deref, DerefMut)]
+#[reflect(Component)]
+pub struct EffectInitializers(pub Vec<EffectInitializer>);
+
+impl EffectInitializers {
+    /// Resets the initializer state.
+    ///
+    /// This resets the internal time for all initializers to zero, and restarts
+    /// any internal particle counters that they might possess.
+    ///
+    /// Use this, for example, to immediately spawn some particles in a spawner
+    /// constructed with [`Spawner::once`].
+    ///
+    /// [`Spawner::once`]: crate::Spawner::once
+    pub fn reset(&mut self) {
+        for initializer in &mut self.0 {
+            initializer.reset();
+        }
+    }
+
+    /// Marks all initializers as either active or inactive.
+    ///
+    /// Inactive initializers don't spawn any particles.
+    pub fn set_active(&mut self, active: bool) {
+        for initializer in &mut self.0 {
+            initializer.set_active(active);
+        }
+    }
+}
+
+/// Holds the runtime state for the initializer of a single particle group on a
+/// particle effect.
+#[derive(Clone, Copy, PartialEq, Reflect, Debug)]
+pub enum EffectInitializer {
+    /// The group uses a spawner.
+    Spawner(EffectSpawner),
+    /// The group uses a cloner (i.e. is a trail or ribbon).
+    Cloner(EffectCloner),
+}
+
+impl EffectInitializer {
+    /// If this initializer is a spawner, returns an immutable reference to it.
+    pub fn get_spawner(&self) -> Option<&EffectSpawner> {
+        match *self {
+            EffectInitializer::Spawner(ref spawner) => Some(spawner),
+            _ => None,
+        }
+    }
+
+    /// Resets the initializer state.
+    ///
+    /// This resets the internal time for this initializer to zero, and
+    /// restarts any internal particle counters that it might possess.
+    ///
+    /// Use this, for example, to immediately spawn some particles in a spawner
+    /// constructed with [`Spawner::once`].
+    ///
+    /// [`Spawner::once`]: crate::Spawner::once
+    pub fn reset(&mut self) {
+        match *self {
+            EffectInitializer::Spawner(mut effect_spawner) => effect_spawner.reset(),
+            EffectInitializer::Cloner(mut effect_cloner) => effect_cloner.reset(),
+        }
+    }
+
+    /// Marks this initializer as either active or inactive.
+    ///
+    /// Inactive initializers don't spawn any particles.
+    pub fn set_active(&mut self, active: bool) {
+        match *self {
+            EffectInitializer::Spawner(mut effect_spawner) => effect_spawner.set_active(active),
+            EffectInitializer::Cloner(mut effect_cloner) => effect_cloner.set_active(active),
+        }
+    }
+}
+
+/// Runtime structure maintaining the state of the spawner for a particle group.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Reflect)]
 pub struct EffectSpawner {
     /// The spawner configuration extracted either from the [`EffectAsset`], or
     /// from any overriden value provided by the user on the [`ParticleEffect`].
@@ -471,20 +662,19 @@ pub struct EffectSpawner {
 
 impl EffectSpawner {
     /// Create a new spawner state from an asset definition.
-    pub fn new(asset: &EffectAsset) -> Self {
-        let spawner = asset.spawner;
+    pub fn new(spawner: &Spawner) -> Self {
         Self {
-            spawner,
             time: if spawner.is_once() && !spawner.starts_immediately {
                 1. // anything > 0
             } else {
                 0.
             },
+            active: spawner.starts_active(),
+            spawner: *spawner,
             curr_spawn_time: 0.,
             limit: 0.,
             spawn_count: 0,
             spawn_remainder: 0.,
-            active: spawner.starts_active(),
         }
     }
 
@@ -603,6 +793,82 @@ impl EffectSpawner {
     }
 }
 
+/// A runtime structure maintaining the state of the cloner for a particle
+/// group.
+#[derive(Default, Clone, Copy, PartialEq, Reflect, Debug)]
+pub struct EffectCloner {
+    /// The cloner configuration extracted either from the [`EffectAsset`] or
+    /// overridden manually.
+    pub cloner: Cloner,
+    /// Accumulated time since last spawn.
+    time: f32,
+    /// Time limit until next spawn.
+    limit: f32,
+    /// The capacity of the group.
+    capacity: u32,
+    /// Whether the cloner is to spawn this frame.
+    pub spawn_this_frame: bool,
+    /// Whether the cloner is active. Defaults to true.
+    pub active: bool,
+}
+
+impl EffectCloner {
+    pub(crate) fn new(cloner: Cloner, capacity: u32) -> EffectCloner {
+        EffectCloner {
+            cloner,
+            time: 0.0,
+            limit: 0.0,
+            capacity,
+            spawn_this_frame: false,
+            active: cloner.starts_active(),
+        }
+    }
+
+    /// Reset the spawner state.
+    ///
+    /// This resets the internal spawner time to zero, and restarts any internal
+    /// particle counter.
+    ///
+    /// [`Spawner::once`]: crate::Spawner::once
+    pub fn reset(&mut self) {
+        self.time = 0.0;
+        self.limit = 0.0;
+    }
+
+    /// Returns true if we should spawn this frame.
+    pub fn tick(&mut self, dt: f32, rng: &mut Pcg32) {
+        if !self.active {
+            self.spawn_this_frame = false;
+            return;
+        }
+
+        if self.limit == 0.0 {
+            self.resample(rng);
+        }
+
+        let new_time = self.time + dt;
+        self.time = new_time;
+
+        self.spawn_this_frame = self.time >= self.limit;
+
+        if self.spawn_this_frame {
+            self.time = 0.0;
+            self.resample(rng);
+        }
+    }
+
+    fn resample(&mut self, rng: &mut Pcg32) {
+        self.limit = self.cloner.period.sample(rng);
+    }
+
+    /// Marks this cloner as either active or inactive.
+    ///
+    /// Inactive cloners don't clone any particles.
+    pub fn set_active(&mut self, active: bool) {
+        self.active = active;
+    }
+}
+
 /// Tick all the [`EffectSpawner`] components of the simulated
 /// [`ParticleEffect`] components.
 ///
@@ -634,14 +900,14 @@ pub fn tick_spawners(
         Entity,
         &ParticleEffect,
         Option<&InheritedVisibility>,
-        Option<&mut EffectSpawner>,
+        Option<&mut EffectInitializers>,
     )>,
 ) {
     trace!("tick_spawners");
 
     let dt = time.delta_seconds();
 
-    for (entity, effect, maybe_inherited_visibility, maybe_spawner) in query.iter_mut() {
+    for (entity, effect, maybe_inherited_visibility, maybe_initializers) in query.iter_mut() {
         // TODO - maybe cache simulation_condition so we don't need to unconditionally
         // query the asset?
         let Some(asset) = effects.get(&effect.handle) else {
@@ -656,13 +922,41 @@ pub fn tick_spawners(
             continue;
         }
 
-        if let Some(mut spawner) = maybe_spawner {
-            spawner.tick(dt, &mut rng.0);
-        } else {
-            let mut spawner = EffectSpawner::new(asset);
-            spawner.tick(dt, &mut rng.0);
-            commands.entity(entity).insert(spawner);
+        if let Some(mut initializers) = maybe_initializers {
+            for initializer in &mut **initializers {
+                match *initializer {
+                    EffectInitializer::Spawner(ref mut effect_spawner) => {
+                        effect_spawner.tick(dt, &mut rng.0);
+                    }
+                    EffectInitializer::Cloner(ref mut effect_cloner) => {
+                        effect_cloner.tick(dt, &mut rng.0);
+                    }
+                }
+            }
+            continue;
         }
+
+        let initializers = asset
+            .init
+            .iter()
+            .enumerate()
+            .map(|(group_index, init)| match *init {
+                Initializer::Spawner(spawner) => {
+                    let mut effect_spawner = EffectSpawner::new(&spawner);
+                    effect_spawner.tick(dt, &mut rng.0);
+                    EffectInitializer::Spawner(effect_spawner)
+                }
+                Initializer::Cloner(cloner) => {
+                    let mut effect_cloner =
+                        EffectCloner::new(cloner, asset.capacities()[group_index]);
+                    effect_cloner.tick(dt, &mut rng.0);
+                    EffectInitializer::Cloner(effect_cloner)
+                }
+            })
+            .collect();
+        commands
+            .entity(entity)
+            .insert(EffectInitializers(initializers));
     }
 }
 
@@ -687,7 +981,11 @@ mod test {
 
     /// Make an `EffectSpawner` wrapping a `Spawner`.
     fn make_effect_spawner(spawner: Spawner) -> EffectSpawner {
-        EffectSpawner::new(&EffectAsset::new(vec![256], spawner, Module::default()))
+        EffectSpawner::new(
+            EffectAsset::new(256, spawner, Module::default()).init[0]
+                .get_spawner()
+                .expect("Expected the first group to have a spawner"),
+        )
     }
 
     #[test]
@@ -908,8 +1206,7 @@ mod test {
 
                 // Add effect asset
                 let mut assets = world.resource_mut::<Assets<EffectAsset>>();
-                let mut asset =
-                    EffectAsset::new(vec![64], test_case.asset_spawner, Module::default());
+                let mut asset = EffectAsset::new(64, test_case.asset_spawner, Module::default());
                 asset.simulation_condition = if test_case.visibility.is_some() {
                     SimulationCondition::WhenVisible
                 } else {
@@ -964,14 +1261,14 @@ mod test {
             if let Some(test_visibility) = test_case.visibility {
                 // Simulated-when-visible effect (SimulationCondition::WhenVisible)
 
-                let (entity, visibility, inherited_visibility, particle_effect, effect_spawner) =
+                let (entity, visibility, inherited_visibility, particle_effect, effect_spawners) =
                     world
                         .query::<(
                             Entity,
                             &Visibility,
                             &InheritedVisibility,
                             &ParticleEffect,
-                            Option<&EffectSpawner>,
+                            Option<&EffectInitializers>,
                         )>()
                         .iter(world)
                         .next()
@@ -985,43 +1282,43 @@ mod test {
                 assert_eq!(particle_effect.handle, handle);
                 if inherited_visibility.get() {
                     // If visible, `tick_spawners()` spawns the EffectSpawner and ticks it
-                    assert!(effect_spawner.is_some());
-                    let effect_spawner = effect_spawner.unwrap();
-                    let actual_spawner = effect_spawner.spawner();
+                    assert!(effect_spawners.is_some());
+                    let effect_spawner = effect_spawners.unwrap()[0].get_spawner().unwrap();
+                    let actual_spawner = effect_spawner.spawner;
 
                     // Check the spawner ticked
                     assert!(effect_spawner.active);
                     assert_eq!(effect_spawner.spawn_remainder, 0.);
                     assert_eq!(effect_spawner.time, cur_time.as_secs_f32());
 
-                    assert_eq!(*actual_spawner, test_case.asset_spawner);
+                    assert_eq!(actual_spawner, test_case.asset_spawner);
                     assert_eq!(effect_spawner.spawn_count, 32);
                 } else {
                     // If not visible, `tick_spawners()` skips the effect entirely so won't spawn an
                     // `EffectSpawner` for it
-                    assert!(effect_spawner.is_none());
+                    assert!(effect_spawners.is_none());
                 }
             } else {
                 // Always-simulated effect (SimulationCondition::Always)
 
-                let (entity, particle_effect, effect_spawner) = world
-                    .query::<(Entity, &ParticleEffect, Option<&EffectSpawner>)>()
+                let (entity, particle_effect, effect_spawners) = world
+                    .query::<(Entity, &ParticleEffect, Option<&EffectInitializers>)>()
                     .iter(world)
                     .next()
                     .unwrap();
                 assert_eq!(entity, effect_entity);
                 assert_eq!(particle_effect.handle, handle);
 
-                assert!(effect_spawner.is_some());
-                let effect_spawner = effect_spawner.unwrap();
-                let actual_spawner = effect_spawner.spawner();
+                assert!(effect_spawners.is_some());
+                let effect_spawner = effect_spawners.unwrap()[0].get_spawner().unwrap();
+                let actual_spawner = effect_spawner.spawner;
 
                 // Check the spawner ticked
                 assert!(effect_spawner.active);
                 assert_eq!(effect_spawner.spawn_remainder, 0.);
                 assert_eq!(effect_spawner.time, cur_time.as_secs_f32());
 
-                assert_eq!(*actual_spawner, test_case.asset_spawner);
+                assert_eq!(actual_spawner, test_case.asset_spawner);
                 assert_eq!(effect_spawner.spawn_count, 32);
             }
         }