diff --git a/Cargo.toml b/Cargo.toml
index 325172c..da7743b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,8 +19,11 @@ exclude = [ "images", "assets" ]
 smallvec = "1.11.0"
 bitflags = "2.3"
 
+# see bevy #16563
+bevy_internal = { version = "0.15", features = ["bevy_image"] }
+
 [dependencies.bevy]
-version = "0.14"
+version = "0.15"
 default-features = false
 features = [
     "bevy_core_pipeline",
@@ -34,4 +37,4 @@ features = [
 ]
 
 [dev-dependencies]
-bevy = "0.14"
+bevy = "0.15"
diff --git a/README.md b/README.md
index 5f4dc24..6d744a0 100644
--- a/README.md
+++ b/README.md
@@ -40,39 +40,31 @@ App::new()
 
 Text:
 ```rs
-commands.spawn(BillboardTextBundle {
-    transform: Transform::from_translation(Vec3::new(0., 2., 0.))
-        .with_scale(Vec3::splat(0.0085)),
-    text: Text::from_sections([
-        TextSection {
-            value: "IMPORTANT".to_string(),
-            style: TextStyle {
-                font_size: 60.0,
-                font: fira_sans_regular_handle.clone(),
-                color: Color::ORANGE,
-            }
-        },
-        TextSection {
-            value: " text".to_string(),
-            style: TextStyle {
-                font_size: 60.0,
-                font: fira_sans_regular_handle.clone(),
-                color: Color::WHITE,
-            }
-        }
-    ]).with_alignment(TextAlignment::CENTER),
-    ..default()
-});
+commands
+    .spawn((
+        BillboardText::default(),
+        TextLayout::new_with_justify(JustifyText::Center),
+        Transform::from_scale(Vec3::splat(0.0085)),
+    ))
+    .with_child((
+        TextSpan::new("IMPORTANT"),
+        TextFont::from_font(fira_sans_regular_handle.clone()).with_font_size(60.0),
+        TextColor::from(Color::Srgba(palettes::css::ORANGE)),
+    ))
+    .with_child((
+        TextSpan::new(" text"),
+        TextFont::from_font(fira_sans_regular_handle.clone()).with_font_size(60.0),
+        TextColor::from(Color::WHITE),
+    ));
 ```
 
 Texture:
 ```rs
-commands.spawn(BillboardTextureBundle {
-    transform: Transform::from_translation(Vec3::new(0., 5., 0.)),
-    texture: BillboardTextureHandle(handle.clone()),
-    mesh: BillboardMeshHandle(meshes.add(Quad::new(Vec2::new(4.0, 4.0)).into()).into()),
-    ..default()
-});
+commands.spawn((
+    BillboardTexture(image_handle.clone()),
+    BillboardMesh(meshes.add(Rectangle::from_size(Vec2::splat(2.0)))),
+    Transform::from_xyz(0.0, 5.0, 0.0),
+));
 ```
 
 Full examples at [examples](examples).
diff --git a/examples/depth.rs b/examples/depth.rs
index 7eef869..889669f 100644
--- a/examples/depth.rs
+++ b/examples/depth.rs
@@ -1,7 +1,6 @@
 use bevy::color::palettes;
 use bevy::prelude::*;
 use bevy_mod_billboard::prelude::*;
-use bevy_mod_billboard::BillboardDepth;
 
 fn main() {
     App::new()
@@ -15,41 +14,31 @@ fn main() {
 const TEXT_SCALE: Vec3 = Vec3::splat(0.0085);
 
 fn setup_billboard(mut commands: Commands, asset_server: Res<AssetServer>) {
-    let fira_sans_regular_handle = asset_server.load("FiraSans-Regular.ttf");
+    let text_font =
+        TextFont::from_font(asset_server.load("FiraSans-Regular.ttf")).with_font_size(60.0);
 
-    commands.spawn(BillboardTextBundle {
-        transform: Transform::from_translation(Vec3::new(0., 0.5, 0.)).with_scale(TEXT_SCALE),
-        text: Text::from_section(
-            "depth enabled",
-            TextStyle {
-                font_size: 60.0,
-                font: fira_sans_regular_handle.clone(),
-                color: Color::WHITE,
-            },
-        )
-        .with_justify(JustifyText::Center),
-        ..default()
-    });
+    commands.spawn((
+        BillboardText::new("depth enabled"),
+        text_font.clone(),
+        TextColor(Color::WHITE),
+        TextLayout::new_with_justify(JustifyText::Center),
+        Transform::from_xyz(0.0, 0.5, 0.0).with_scale(TEXT_SCALE),
+    ));
 
-    commands.spawn(BillboardTextBundle {
-        transform: Transform::from_translation(Vec3::new(0., -0.5, 0.)).with_scale(TEXT_SCALE),
-        text: Text::from_section(
-            "depth disabled",
-            TextStyle {
-                font_size: 60.0,
-                font: fira_sans_regular_handle.clone(),
-                color: Color::WHITE,
-            },
-        )
-        .with_justify(JustifyText::Center),
-        billboard_depth: BillboardDepth(false),
-        ..default()
-    });
+    commands.spawn((
+        BillboardText::new("depth disabled"),
+        BillboardDepth(false),
+        text_font.clone(),
+        TextColor(Color::WHITE),
+        TextLayout::new_with_justify(JustifyText::Center),
+        Transform::from_xyz(0.0, -0.5, 0.0).with_scale(TEXT_SCALE),
+    ));
 }
 
 // Important bits are above, the code below is for camera, reference cube and rotation
 
 #[derive(Component)]
+#[require(Transform)]
 pub struct CameraHolder;
 
 fn setup_scene(
@@ -57,26 +46,22 @@ fn setup_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands
-        .spawn((CameraHolder, Transform::IDENTITY, GlobalTransform::IDENTITY))
-        .with_children(|parent| {
-            parent.spawn(Camera3dBundle {
-                transform: Transform::from_translation(Vec3::new(5., 0., 0.))
-                    .looking_at(Vec3::ZERO, Vec3::Y),
-                ..default()
-            });
-        });
-
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Cuboid::default()),
-        material: materials.add(Color::Srgba(palettes::css::BEIGE)),
-        transform: Transform::from_translation(Vec3::new(1., 0., 0.)),
-        ..default()
+    commands.spawn(CameraHolder).with_children(|parent| {
+        parent.spawn((
+            Camera3d::default(),
+            Transform::from_xyz(5., 0., 0.).looking_at(Vec3::ZERO, Vec3::Y),
+        ));
     });
+
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::Srgba(palettes::css::BEIGE))),
+        Transform::from_xyz(1., 0., 0.),
+    ));
 }
 
 fn rotate_camera(mut camera: Query<&mut Transform, With<CameraHolder>>, time: Res<Time>) {
     let mut camera = camera.single_mut();
 
-    camera.rotate_y(time.delta_seconds());
+    camera.rotate_y(time.delta_secs());
 }
diff --git a/examples/lock_rotation.rs b/examples/lock_rotation.rs
index 499255e..06e8c34 100644
--- a/examples/lock_rotation.rs
+++ b/examples/lock_rotation.rs
@@ -1,7 +1,6 @@
 use bevy::color::palettes;
 use bevy::prelude::*;
 use bevy_mod_billboard::prelude::*;
-use bevy_mod_billboard::BillboardLockAxis;
 
 fn main() {
     App::new()
@@ -13,42 +12,28 @@ fn main() {
 }
 
 fn setup_billboard(mut commands: Commands, asset_server: Res<AssetServer>) {
-    let fira_sans_regular_handle = asset_server.load("FiraSans-Regular.ttf");
-    commands.spawn((
-        BillboardTextBundle {
-            transform: Transform::from_scale(Vec3::splat(0.0085))
-                .looking_at(Vec3::splat(5.0), Vec3::Y),
-            text: Text::from_sections([
-                TextSection {
-                    value: "LOCKED".to_string(),
-                    style: TextStyle {
-                        font_size: 60.0,
-                        font: fira_sans_regular_handle.clone(),
-                        color: Color::Srgba(palettes::css::ORANGE),
-                    },
-                },
-                TextSection {
-                    value: " text".to_string(),
-                    style: TextStyle {
-                        font_size: 60.0,
-                        font: fira_sans_regular_handle.clone(),
-                        color: Color::WHITE,
-                    },
-                },
-            ])
-            .with_justify(JustifyText::Center),
-            ..default()
-        },
-        BillboardLockAxis {
-            rotation: true,
-            ..default()
-        },
-    ));
+    let text_font =
+        TextFont::from_font(asset_server.load("FiraSans-Regular.ttf")).with_font_size(60.0);
+
+    commands
+        .spawn((
+            BillboardText::default(),
+            TextLayout::new_with_justify(JustifyText::Center),
+            Transform::from_scale(Vec3::splat(0.0085)).looking_at(Vec3::splat(5.0), Vec3::Y),
+            BillboardLockAxis::from_lock_rotation(true),
+        ))
+        .with_child((
+            TextSpan::new("LOCKED"),
+            text_font.clone(),
+            TextColor(Color::Srgba(palettes::css::ORANGE)),
+        ))
+        .with_child((TextSpan::new(" text"), text_font, TextColor(Color::WHITE)));
 }
 
 // Important bits are above, the code below is for camera, reference cube and rotation
 
 #[derive(Component)]
+#[require(Transform)]
 pub struct CameraHolder;
 
 fn setup_scene(
@@ -56,26 +41,22 @@ fn setup_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands
-        .spawn((CameraHolder, Transform::IDENTITY, GlobalTransform::IDENTITY))
-        .with_children(|parent| {
-            parent.spawn(Camera3dBundle {
-                transform: Transform::from_translation(Vec3::new(5., 0., 0.))
-                    .looking_at(Vec3::ZERO, Vec3::Y),
-                ..default()
-            });
-        });
-
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Cuboid::default()),
-        material: materials.add(Color::Srgba(palettes::css::GRAY)),
-        transform: Transform::from_translation(Vec3::NEG_Y),
-        ..default()
+    commands.spawn(CameraHolder).with_children(|parent| {
+        parent.spawn((
+            Camera3d::default(),
+            Transform::from_xyz(5., 0., 0.).looking_at(Vec3::ZERO, Vec3::Y),
+        ));
     });
+
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::Srgba(palettes::css::GRAY))),
+        Transform::from_translation(Vec3::NEG_Y),
+    ));
 }
 
 fn rotate_camera(mut camera: Query<&mut Transform, With<CameraHolder>>, time: Res<Time>) {
     let mut camera = camera.single_mut();
 
-    camera.rotate_y(time.delta_seconds());
+    camera.rotate_y(time.delta_secs());
 }
diff --git a/examples/lock_y.rs b/examples/lock_y.rs
index 6784c6a..e45221f 100644
--- a/examples/lock_y.rs
+++ b/examples/lock_y.rs
@@ -1,7 +1,6 @@
 use bevy::color::palettes;
 use bevy::prelude::*;
 use bevy_mod_billboard::prelude::*;
-use bevy_mod_billboard::{BillboardLockAxis, BillboardLockAxisBundle};
 
 fn main() {
     App::new()
@@ -18,29 +17,25 @@ fn setup_billboard(
     mut meshes: ResMut<Assets<Mesh>>,
 ) {
     let image_handle = asset_server.load("tree.png");
-    commands.spawn(BillboardLockAxisBundle {
-        billboard_bundle: BillboardTextureBundle {
-            transform: Transform::from_translation(Vec3::new(2.0, 2.0, 0.0)),
-            texture: BillboardTextureHandle(image_handle.clone()),
-            mesh: BillboardMeshHandle(meshes.add(Rectangle::from_size(Vec2::new(2.0, 4.0)))),
-            ..default()
-        },
-        lock_axis: BillboardLockAxis {
-            y_axis: true,
-            ..Default::default()
-        },
-    });
-    commands.spawn(BillboardTextureBundle {
-        transform: Transform::from_translation(Vec3::new(-2.0, 2.0, 0.0)),
-        texture: BillboardTextureHandle(image_handle),
-        mesh: BillboardMeshHandle(meshes.add(Rectangle::from_size(Vec2::new(2.0, 4.0)))),
-        ..default()
-    });
+
+    commands.spawn((
+        BillboardTexture(image_handle.clone()),
+        BillboardMesh(meshes.add(Rectangle::new(2.0, 4.0))),
+        Transform::from_xyz(2.0, 2.0, 0.0),
+        BillboardLockAxis::from_lock_y(true),
+    ));
+
+    commands.spawn((
+        BillboardTexture(image_handle),
+        BillboardMesh(meshes.add(Rectangle::new(2.0, 4.0))),
+        Transform::from_xyz(-2.0, 2.0, 0.0),
+    ));
 }
 
 // Important bits are above, the code below is for camera, reference plane and rotation
 
 #[derive(Component)]
+#[require(Transform)]
 pub struct CameraHolder;
 
 fn setup_scene(
@@ -48,26 +43,22 @@ fn setup_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands.spawn(PbrBundle {
-        transform: Transform::from_scale(Vec3::splat(3.0)),
-        mesh: meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.5))),
-        material: materials.add(Color::Srgba(palettes::css::SILVER)),
-        ..default()
-    });
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.5)))),
+        MeshMaterial3d(materials.add(Color::Srgba(palettes::css::SILVER))),
+        Transform::from_scale(Vec3::splat(3.0)),
+    ));
 
-    commands
-        .spawn((CameraHolder, Transform::IDENTITY, GlobalTransform::IDENTITY))
-        .with_children(|parent| {
-            parent.spawn(Camera3dBundle {
-                transform: Transform::from_translation(Vec3::new(0., 15., 2.))
-                    .looking_at(Vec3::ZERO, Vec3::Y),
-                ..default()
-            });
-        });
+    commands.spawn(CameraHolder).with_children(|parent| {
+        parent.spawn((
+            Camera3d::default(),
+            Transform::from_xyz(0., 15., 2.).looking_at(Vec3::ZERO, Vec3::Y),
+        ));
+    });
 }
 
 fn rotate_camera(mut camera: Query<&mut Transform, With<CameraHolder>>, time: Res<Time>) {
     let mut camera = camera.single_mut();
 
-    camera.rotate_y(time.delta_seconds());
+    camera.rotate_y(time.delta_secs());
 }
diff --git a/examples/stress_test.rs b/examples/stress_test.rs
index 463ae44..c66ce14 100644
--- a/examples/stress_test.rs
+++ b/examples/stress_test.rs
@@ -39,17 +39,15 @@ struct Settings {
 }
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut meshes: ResMut<Assets<Mesh>>) {
-    let image_handle: Handle<Image> = asset_server.load("rust-logo-256x256.png");
-    let billboard_texture = BillboardTextureHandle(image_handle);
-    let mesh_handle = meshes.add(Rectangle::from_size(Vec2::splat(1.0)));
-    let billboard_mesh = BillboardMeshHandle(mesh_handle);
-    let fira_sans_regular_handle = asset_server.load("FiraSans-Regular.ttf");
+    let billboard_texture = BillboardTexture(asset_server.load("rust-logo-256x256.png"));
+    let billboard_mesh = BillboardMesh(meshes.add(Rectangle::from_size(Vec2::splat(1.0))));
+    let text_font =
+        TextFont::from_font(asset_server.load("FiraSans-Regular.ttf")).with_font_size(60.0);
 
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_translation(Vec3::new(0., 0., 50.))
-            .looking_at(Vec3::ZERO, Vec3::Y),
-        ..Default::default()
-    });
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0., 0., 50.).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
 
     for x in -10..=10 {
         for y in -10..=10 {
@@ -57,31 +55,20 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut meshes: Res
                 let translation = Vec3::new(x as f32, y as f32, z as f32);
 
                 if std::env::args().any(|arg| arg == "text") {
-                    commands.spawn(BillboardTextBundle {
-                        transform: Transform {
-                            translation,
-                            rotation: Quat::IDENTITY,
-                            scale: Vec3::splat(0.0085),
-                        },
-                        text: Text::from_section(
-                            "STRESS",
-                            TextStyle {
-                                font_size: 60.0,
-                                font: fira_sans_regular_handle.clone(),
-                                color: Color::Srgba(palettes::css::ORANGE),
-                            },
-                        ),
-                        ..default()
-                    });
+                    commands.spawn((
+                        BillboardText::new("STRESS"),
+                        text_font.clone(),
+                        TextColor(Color::Srgba(palettes::css::ORANGE)),
+                        Transform::from_translation(translation).with_scale(Vec3::splat(0.0085)),
+                    ));
                 }
 
                 if std::env::args().any(|arg| arg == "texture") {
-                    commands.spawn(BillboardTextureBundle {
-                        texture: billboard_texture.clone(),
-                        mesh: billboard_mesh.clone(),
-                        transform: Transform::from_translation(translation),
-                        ..Default::default()
-                    });
+                    commands.spawn((
+                        billboard_texture.clone(),
+                        billboard_mesh.clone(),
+                        Transform::from_translation(translation),
+                    ));
                 }
             }
         }
@@ -95,7 +82,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut meshes: Res
 
 fn recompute_billboards(
     mut text_query: Query<&mut Text>,
-    mut billboard_query: Query<&mut BillboardTextureHandle>,
+    mut billboard_query: Query<&mut BillboardTexture>,
     settings: Res<Settings>,
 ) {
     if settings.recompute_text {
diff --git a/examples/text.rs b/examples/text.rs
index 03d94f6..60bd79f 100644
--- a/examples/text.rs
+++ b/examples/text.rs
@@ -13,34 +13,29 @@ fn main() {
 
 fn setup_billboard(mut commands: Commands, asset_server: Res<AssetServer>) {
     let fira_sans_regular_handle = asset_server.load("FiraSans-Regular.ttf");
-    commands.spawn(BillboardTextBundle {
-        transform: Transform::from_scale(Vec3::splat(0.0085)),
-        text: Text::from_sections([
-            TextSection {
-                value: "IMPORTANT".to_string(),
-                style: TextStyle {
-                    font_size: 60.0,
-                    font: fira_sans_regular_handle.clone(),
-                    color: Color::Srgba(palettes::css::ORANGE),
-                },
-            },
-            TextSection {
-                value: " text".to_string(),
-                style: TextStyle {
-                    font_size: 60.0,
-                    font: fira_sans_regular_handle.clone(),
-                    color: Color::WHITE,
-                },
-            },
-        ])
-        .with_justify(JustifyText::Center),
-        ..default()
-    });
+
+    commands
+        .spawn((
+            BillboardText::default(),
+            TextLayout::new_with_justify(JustifyText::Left),
+            Transform::from_scale(Vec3::splat(0.0085)),
+        ))
+        .with_child((
+            TextSpan::new("IMPORTANT"),
+            TextFont::from_font(fira_sans_regular_handle.clone()).with_font_size(60.0),
+            TextColor::from(Color::Srgba(palettes::css::ORANGE)),
+        ))
+        .with_child((
+            TextSpan::new(" text"),
+            TextFont::from_font(fira_sans_regular_handle.clone()).with_font_size(60.0),
+            TextColor::from(Color::WHITE),
+        ));
 }
 
 // Important bits are above, the code below is for camera, reference cube and rotation
 
 #[derive(Component)]
+#[require(Transform)]
 pub struct CameraHolder;
 
 fn setup_scene(
@@ -48,26 +43,22 @@ fn setup_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands
-        .spawn((CameraHolder, Transform::IDENTITY, GlobalTransform::IDENTITY))
-        .with_children(|parent| {
-            parent.spawn(Camera3dBundle {
-                transform: Transform::from_translation(Vec3::new(5., 0., 0.))
-                    .looking_at(Vec3::ZERO, Vec3::Y),
-                ..default()
-            });
-        });
-
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Cuboid::default()),
-        material: materials.add(Color::Srgba(palettes::css::GRAY)),
-        transform: Transform::from_translation(Vec3::NEG_Y),
-        ..default()
+    commands.spawn(CameraHolder).with_children(|parent| {
+        parent.spawn((
+            Camera3d::default(),
+            Transform::from_xyz(5., 0., 0.).looking_at(Vec3::ZERO, Vec3::Y),
+        ));
     });
+
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::Srgba(palettes::css::GRAY))),
+        Transform::from_translation(Vec3::NEG_Y),
+    ));
 }
 
 fn rotate_camera(mut camera: Query<&mut Transform, With<CameraHolder>>, time: Res<Time>) {
     let mut camera = camera.single_mut();
 
-    camera.rotate_y(time.delta_seconds());
+    camera.rotate_y(time.delta_secs());
 }
diff --git a/examples/texture.rs b/examples/texture.rs
index a37260e..08c9073 100644
--- a/examples/texture.rs
+++ b/examples/texture.rs
@@ -17,16 +17,16 @@ fn setup_billboard(
     mut meshes: ResMut<Assets<Mesh>>,
 ) {
     let image_handle = asset_server.load("rust-logo-256x256.png");
-    commands.spawn(BillboardTextureBundle {
-        texture: BillboardTextureHandle(image_handle),
-        mesh: BillboardMeshHandle(meshes.add(Rectangle::from_size(Vec2::splat(2.0)))),
-        ..default()
-    });
+    commands.spawn((
+        BillboardTexture(image_handle.clone()),
+        BillboardMesh(meshes.add(Rectangle::from_size(Vec2::splat(2.0)))),
+    ));
 }
 
 // Important bits are above, the code below is for camera, reference cube and rotation
 
 #[derive(Component)]
+#[require(Transform)]
 pub struct CameraHolder;
 
 fn setup_scene(
@@ -34,26 +34,22 @@ fn setup_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands
-        .spawn((CameraHolder, Transform::IDENTITY, GlobalTransform::IDENTITY))
-        .with_children(|parent| {
-            parent.spawn(Camera3dBundle {
-                transform: Transform::from_translation(Vec3::new(5., 0., 0.))
-                    .looking_at(Vec3::ZERO, Vec3::Y),
-                ..default()
-            });
-        });
-
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Cuboid::default()),
-        material: materials.add(Color::Srgba(palettes::css::GRAY)),
-        transform: Transform::from_translation(Vec3::NEG_Y * 2.),
-        ..default()
+    commands.spawn(CameraHolder).with_children(|parent| {
+        parent.spawn((
+            Camera3d::default(),
+            Transform::from_xyz(5., 0., 0.).looking_at(Vec3::ZERO, Vec3::Y),
+        ));
     });
+
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::Srgba(palettes::css::GRAY))),
+        Transform::from_translation(Vec3::NEG_Y * 2.),
+    ));
 }
 
 fn rotate_camera(mut camera: Query<&mut Transform, With<CameraHolder>>, time: Res<Time>) {
     let mut camera = camera.single_mut();
 
-    camera.rotate_y(time.delta_seconds());
+    camera.rotate_y(time.delta_secs());
 }
diff --git a/examples/transform_propagation.rs b/examples/transform_propagation.rs
index c42260c..287bafa 100644
--- a/examples/transform_propagation.rs
+++ b/examples/transform_propagation.rs
@@ -24,40 +24,27 @@ fn setup_billboard(
 
     commands
         .spawn((
-            PbrBundle {
-                mesh: meshes.add(Cuboid::default()),
-                material: materials.add(Color::Srgba(palettes::css::GRAY)),
-                transform: Transform::from_translation(Vec3::new(0.0, -2.0, 1.0)),
-                ..default()
-            },
             ParentCube,
+            Mesh3d(meshes.add(Cuboid::default())),
+            MeshMaterial3d(materials.add(Color::Srgba(palettes::css::GRAY))),
+            Transform::from_translation(Vec3::new(0.0, -2.0, 1.0)),
         ))
-        .with_children(|parent| {
-            parent.spawn(BillboardTextBundle {
-                transform: Transform::from_translation(Vec3::new(0., 1.0, 0.))
-                    .with_scale(Vec3::splat(0.0085)),
-                text: Text::from_section(
-                    "parented text",
-                    TextStyle {
-                        font_size: 60.0,
-                        font: fira_sans_regular_handle.clone(),
-                        color: Color::WHITE,
-                    },
-                )
-                .with_justify(JustifyText::Center),
-                ..default()
-            });
-        });
+        .with_child((
+            BillboardText::new("parented text"),
+            TextFont::from_font(fira_sans_regular_handle).with_font_size(60.0),
+            TextColor(Color::WHITE),
+            Transform::from_xyz(0.0, 1.0, 0.0).with_scale(Vec3::splat(0.0085)),
+            TextLayout::new_with_justify(JustifyText::Center),
+        ));
 }
 
 // Important bits are above, the code below is for camera, reference cube and rotation
 
 fn setup_scene(mut commands: Commands) {
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_translation(Vec3::new(5., 0., 0.))
-            .looking_at(Vec3::ZERO, Vec3::Y),
-        ..default()
-    });
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(5.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
 }
 
 fn move_cube(
@@ -70,8 +57,8 @@ fn move_cube(
 
     let direction_vec = if *direction { Vec3::Z } else { Vec3::NEG_Z };
 
-    parent_cube.translation += time.delta_seconds() * direction_vec;
-    *accumulated += time.delta_seconds();
+    parent_cube.translation += time.delta_secs() * direction_vec;
+    *accumulated += time.delta_secs();
 
     if *accumulated >= 2.0 {
         *direction = !*direction;
diff --git a/src/lib.rs b/src/lib.rs
index 0d1e50c..d6b5fcc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,18 +6,83 @@ mod utils;
 
 use crate::text::{BillboardTextBounds, BillboardTextHandles};
 use bevy::prelude::*;
+use bevy::render::extract_component::ExtractComponent;
 use bevy::sprite::Anchor;
+use bevy::text::{TextRoot, TextSpanAccess};
 
 pub(self) const BILLBOARD_SHADER_HANDLE: Handle<Shader> =
     Handle::weak_from_u128(12823766040132746076);
 
-#[derive(Clone, Component, Reflect, Default)]
+/// Marker component for a billboarded texture.
+///
+/// Additionally insert a [`BillboardMesh`] to function.
+#[derive(Clone, Component, Default, Reflect)]
 #[reflect(Component)]
-pub struct BillboardMeshHandle(pub Handle<Mesh>);
+#[require(Billboard, BillboardMesh, Transform, Visibility)]
+pub struct BillboardTexture(pub Handle<Image>);
+
+/// Marker component for billboarded text.
+///
+/// Optionally insert [`TextSpan`] children to render separate sections.
+///
+/// # Warning
+///
+/// This component is incompatible with Bevy's `Text` and `Text2d`!
+/// Bevy will attempt to render the `Text` in the UI and `Text2d` as 2D
+/// text, corrupting the internal `TextLayoutInfo` used by billboarding.
+///
+/// If you are not using `TextSpan` children, set the `String` field of
+/// this struct.
+#[derive(Clone, Component, Default)]
+#[require(
+    Billboard,
+    BillboardTextBounds,
+    BillboardTextHandles,
+    TextLayout,
+    TextFont,
+    TextColor,
+    Anchor,
+    Transform,
+    Visibility
+)]
+pub struct BillboardText(pub String);
+
+impl BillboardText {
+    pub fn new(value: impl Into<String>) -> Self {
+        Self(value.into())
+    }
+}
+
+impl TextRoot for BillboardText {}
+
+impl TextSpanAccess for BillboardText {
+    fn read_span(&self) -> &str {
+        self.0.as_str()
+    }
+    fn write_span(&mut self) -> &mut String {
+        &mut self.0
+    }
+}
+
+impl From<&str> for BillboardText {
+    fn from(value: &str) -> Self {
+        Self(String::from(value))
+    }
+}
+
+impl From<String> for BillboardText {
+    fn from(value: String) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Clone, Component, Default)]
+#[component(storage = "SparseSet")]
+struct BillboardTextNeedsRerender;
 
 #[derive(Clone, Component, Reflect, Default)]
 #[reflect(Component)]
-pub struct BillboardTextureHandle(pub Handle<Image>);
+pub struct BillboardMesh(pub Handle<Mesh>);
 
 #[derive(Clone, Copy, Component, Debug, Reflect)]
 pub struct BillboardDepth(pub bool);
@@ -28,7 +93,8 @@ impl Default for BillboardDepth {
     }
 }
 
-#[derive(Default, Clone, Copy, Component, Debug, Reflect)]
+#[derive(Default, Clone, Copy, Component, ExtractComponent, Debug, Reflect)]
+#[require(BillboardDepth)]
 pub struct Billboard;
 
 #[derive(Default, Clone, Copy, Component, Debug, Reflect)]
@@ -37,43 +103,39 @@ pub struct BillboardLockAxis {
     pub rotation: bool,
 }
 
-#[derive(Bundle, Default)]
-pub struct BillboardLockAxisBundle<T: Bundle> {
-    pub billboard_bundle: T,
-    pub lock_axis: BillboardLockAxis,
-}
+impl BillboardLockAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
 
-#[derive(Bundle, Default)]
-pub struct BillboardTextureBundle {
-    pub billboard: Billboard,
-    pub mesh: BillboardMeshHandle,
-    pub texture: BillboardTextureHandle,
-    pub transform: Transform,
-    pub global_transform: GlobalTransform,
-    pub visibility: Visibility,
-    pub inherited_visibility: InheritedVisibility,
-    pub view_visibility: ViewVisibility,
-    pub billboard_depth: BillboardDepth,
-}
+    pub fn from_lock_y(y_axis: bool) -> Self {
+        Self {
+            y_axis,
+            ..default()
+        }
+    }
+
+    pub fn from_lock_rotation(rotation: bool) -> Self {
+        Self {
+            rotation,
+            ..default()
+        }
+    }
 
-#[derive(Bundle, Default)]
-pub struct BillboardTextBundle {
-    pub billboard: Billboard,
-    pub text: Text,
-    pub text_bounds: BillboardTextBounds,
-    pub text_anchor: Anchor,
-    pub transform: Transform,
-    pub global_transform: GlobalTransform,
-    pub visibility: Visibility,
-    pub inherited_visibility: InheritedVisibility,
-    pub view_visibility: ViewVisibility,
-    pub billboard_depth: BillboardDepth,
-    pub billboard_text_handles: BillboardTextHandles,
+    pub fn with_lock_y(mut self, y_axis: bool) -> Self {
+        self.y_axis = y_axis;
+        self
+    }
+
+    pub fn with_lock_rotation(mut self, rotation: bool) -> Self {
+        self.rotation = rotation;
+        self
+    }
 }
 
 pub mod prelude {
     pub use crate::{
-        plugin::BillboardPlugin, text::BillboardTextBounds, BillboardMeshHandle,
-        BillboardTextBundle, BillboardTextureBundle, BillboardTextureHandle,
+        plugin::BillboardPlugin, text::BillboardTextBounds, BillboardDepth, BillboardLockAxis,
+        BillboardMesh, BillboardText, BillboardTexture,
     };
 }
diff --git a/src/pipeline.rs b/src/pipeline.rs
index 8f4152d..85dfe0c 100644
--- a/src/pipeline.rs
+++ b/src/pipeline.rs
@@ -5,6 +5,7 @@ use bevy::core_pipeline::core_3d::Transparent3d;
 use bevy::ecs::query::ROQueryItem;
 use bevy::ecs::system::lifetimeless::{Read, SRes};
 use bevy::ecs::system::{SystemParamItem, SystemState};
+use bevy::image::BevyDefault;
 use bevy::log::error;
 use bevy::math::Mat4;
 use bevy::prelude::{
@@ -12,7 +13,10 @@ use bevy::prelude::{
     ResMut, Resource, With, World,
 };
 use bevy::render::extract_component::{ComponentUniforms, DynamicUniformIndex};
-use bevy::render::mesh::{GpuBufferInfo, GpuMesh, MeshVertexBufferLayoutRef, PrimitiveTopology};
+use bevy::render::mesh::allocator::MeshAllocator;
+use bevy::render::mesh::{
+    MeshVertexBufferLayoutRef, PrimitiveTopology, RenderMesh, RenderMeshBufferInfo,
+};
 use bevy::render::render_asset::RenderAssets;
 use bevy::render::render_phase::{
     DrawFunctions, PhaseItemExtraIndex, RenderCommand, RenderCommandResult, SetItemPipeline,
@@ -27,9 +31,9 @@ use bevy::render::render_resource::{
     SpecializedMeshPipelines, TextureFormat, TextureSampleType, TextureViewDimension, VertexState,
 };
 use bevy::render::renderer::RenderDevice;
-use bevy::render::texture::{BevyDefault, GpuImage};
+use bevy::render::texture::GpuImage;
 use bevy::render::view::{
-    ExtractedView, ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms, VisibleEntities,
+    ExtractedView, RenderVisibleEntities, ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms,
 };
 use bevy::sprite::SpriteAssetEvents;
 use bevy::utils;
@@ -144,16 +148,15 @@ pub fn prepare_billboard_bind_group(
 }
 
 pub fn queue_billboard_texture(
-    mut views: Query<(Entity, &ExtractedView, &VisibleEntities)>,
+    mut views: Query<(Entity, &ExtractedView, &RenderVisibleEntities, &Msaa)>,
     mut transparent_render_phases: ResMut<ViewSortedRenderPhases<Transparent3d>>,
     mut pipeline_cache: ResMut<PipelineCache>,
     mut image_bind_groups: ResMut<BillboardImageBindGroups>,
     mut billboard_pipelines: ResMut<SpecializedMeshPipelines<BillboardPipeline>>,
     render_device: Res<RenderDevice>,
     transparent_draw_functions: Res<DrawFunctions<Transparent3d>>,
-    msaa: Res<Msaa>,
     billboard_pipeline: Res<BillboardPipeline>,
-    (gpu_images, gpu_meshes): (Res<RenderAssets<GpuImage>>, Res<RenderAssets<GpuMesh>>),
+    (gpu_images, gpu_meshes): (Res<RenderAssets<GpuImage>>, Res<RenderAssets<RenderMesh>>),
     events: Res<SpriteAssetEvents>,
     billboards: Query<(
         &BillboardUniform,
@@ -174,7 +177,7 @@ pub fn queue_billboard_texture(
         };
     }
 
-    for (view_entity, view, visible_entities) in &mut views {
+    for (view_entity, view, visible_entities, msaa) in &mut views {
         let Some(transparent_phase) = transparent_render_phases.get_mut(&view_entity) else {
             continue;
         };
@@ -187,7 +190,7 @@ pub fn queue_billboard_texture(
         let rangefinder = view.rangefinder3d();
 
         for visible_entity in visible_entities.iter::<With<Billboard>>() {
-            let Ok((uniform, mesh, image, billboard)) = billboards.get(*visible_entity) else {
+            let Ok((uniform, mesh, image, billboard)) = billboards.get(visible_entity.0) else {
                 continue;
             };
             let Some(gpu_image) = gpu_images.get(image.id) else {
@@ -431,6 +434,7 @@ impl SpecializedMeshPipeline for BillboardPipeline {
                 alpha_to_coverage_enabled: false,
             },
             push_constant_ranges: vec![],
+            zero_initialize_workgroup_memory: false,
         })
     }
 }
@@ -470,7 +474,7 @@ impl<const I: usize> RenderCommand<Transparent3d> for SetBillboardBindGroup<I> {
         let billboard_bind_group = billboard_bind_group.into_inner();
 
         let Some(billboard_index) = billboard_index else {
-            return RenderCommandResult::Failure;
+            return RenderCommandResult::Skip;
         };
 
         pass.set_bind_group(I, &billboard_bind_group.value, &[billboard_index.index()]);
@@ -495,7 +499,7 @@ impl<const I: usize> RenderCommand<Transparent3d> for SetBillboardTextureBindGro
         let images = images.into_inner();
 
         let Some(billboard_texture) = billboard_texture else {
-            return RenderCommandResult::Failure;
+            return RenderCommandResult::Skip;
         };
 
         let bind_group = images.values.get(&billboard_texture.id).unwrap();
@@ -507,7 +511,7 @@ impl<const I: usize> RenderCommand<Transparent3d> for SetBillboardTextureBindGro
 
 pub struct DrawBillboardMesh;
 impl RenderCommand<Transparent3d> for DrawBillboardMesh {
-    type Param = SRes<RenderAssets<GpuMesh>>;
+    type Param = (SRes<RenderAssets<RenderMesh>>, SRes<MeshAllocator>);
     type ViewQuery = ();
     type ItemQuery = Read<RenderBillboardMesh>;
 
@@ -515,34 +519,50 @@ impl RenderCommand<Transparent3d> for DrawBillboardMesh {
         _item: &Transparent3d,
         _view: ROQueryItem<'w, Self::ViewQuery>,
         mesh: Option<ROQueryItem<'w, Self::ItemQuery>>,
-        meshes: SystemParamItem<'w, '_, Self::Param>,
+        (meshes, mesh_allocator): SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
         let Some(mesh) = mesh else {
-            return RenderCommandResult::Failure;
+            return RenderCommandResult::Skip;
         };
 
-        if let Some(gpu_mesh) = meshes.into_inner().get(mesh.id) {
-            pass.set_vertex_buffer(0, gpu_mesh.vertex_buffer.slice(..));
-
-            match &gpu_mesh.buffer_info {
-                GpuBufferInfo::Indexed {
-                    buffer,
-                    index_format,
-                    count,
-                } => {
-                    pass.set_index_buffer(buffer.slice(..), 0, *index_format);
-                    pass.draw_indexed(0..*count, 0, 0..1);
-                }
-                GpuBufferInfo::NonIndexed => {
-                    pass.draw(0..gpu_mesh.vertex_count, 0..1);
-                }
-            }
+        let Some(gpu_mesh) = meshes.into_inner().get(mesh.id) else {
+            return RenderCommandResult::Skip;
+        };
 
-            RenderCommandResult::Success
-        } else {
-            RenderCommandResult::Failure
+        let mesh_allocator = mesh_allocator.into_inner();
+        let Some(vertex_buffer_slice) = mesh_allocator.mesh_vertex_slice(&mesh.id) else {
+            return RenderCommandResult::Skip;
+        };
+
+        pass.set_vertex_buffer(0, vertex_buffer_slice.buffer.slice(..));
+
+        match &gpu_mesh.buffer_info {
+            RenderMeshBufferInfo::Indexed {
+                index_format,
+                count,
+            } => {
+                let Some(index_buffer_slice) = mesh_allocator.mesh_index_slice(&mesh.id) else {
+                    return RenderCommandResult::Skip;
+                };
+
+                pass.set_index_buffer(index_buffer_slice.buffer.slice(..), 0, *index_format);
+                pass.draw_indexed(
+                    index_buffer_slice.range.start..(index_buffer_slice.range.start + count),
+                    vertex_buffer_slice.range.start as i32,
+                    0..1,
+                );
+            }
+            RenderMeshBufferInfo::NonIndexed => {
+                pass.draw(
+                    vertex_buffer_slice.range.start
+                        ..(vertex_buffer_slice.range.start + gpu_mesh.vertex_count),
+                    0..1,
+                );
+            }
         }
+
+        RenderCommandResult::Success
     }
 }
 
diff --git a/src/plugin.rs b/src/plugin.rs
index d26b434..7b2e5cd 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -2,20 +2,21 @@ use crate::pipeline::{
     prepare_billboard_bind_group, prepare_billboard_view_bind_groups, queue_billboard_texture,
     BillboardImageBindGroups, BillboardPipeline, BillboardUniform, DrawBillboard,
 };
-use crate::text::{extract_billboard_text, update_billboard_text_layout};
-use crate::texture::extract_billboard_texture;
-use crate::{
-    Billboard, BillboardMeshHandle, BillboardTextBounds, BillboardTextureHandle,
-    BILLBOARD_SHADER_HANDLE,
+use crate::text::{
+    detect_billboard_text_color_change, extract_billboard_text, update_billboard_text_layout,
+    BillboardTextHandles,
 };
+use crate::texture::extract_billboard_texture;
+use crate::{prelude::*, Billboard, BILLBOARD_SHADER_HANDLE};
 use bevy::prelude::*;
 use bevy::render::camera::CameraUpdateSystem;
-use bevy::render::extract_component::UniformComponentPlugin;
+use bevy::render::extract_component::{ExtractComponentPlugin, UniformComponentPlugin};
 use bevy::render::render_phase::AddRenderCommand;
 use bevy::render::render_resource::SpecializedMeshPipelines;
 use bevy::render::view::check_visibility;
 use bevy::render::view::VisibilitySystems::CheckVisibility;
 use bevy::render::{RenderApp, RenderSet};
+use bevy::text::detect_text_needs_rerender;
 use bevy::{asset::load_internal_asset, core_pipeline::core_3d::Transparent3d, render::Render};
 
 pub struct BillboardPlugin;
@@ -30,13 +31,23 @@ impl Plugin for BillboardPlugin {
         );
 
         app.add_plugins(UniformComponentPlugin::<BillboardUniform>::default())
-            .register_type::<BillboardMeshHandle>()
-            .register_type::<BillboardTextureHandle>()
+            .add_plugins(ExtractComponentPlugin::<Billboard>::default())
+            .register_type::<BillboardMesh>()
+            .register_type::<BillboardTexture>()
             .register_type::<BillboardTextBounds>()
+            .register_type::<BillboardTextHandles>()
             .add_systems(
                 PostUpdate,
                 (
-                    update_billboard_text_layout.ambiguous_with(CameraUpdateSystem),
+                    (
+                        (
+                            detect_text_needs_rerender::<BillboardText>,
+                            detect_billboard_text_color_change,
+                        ),
+                        update_billboard_text_layout,
+                    )
+                        .chain()
+                        .ambiguous_with(CameraUpdateSystem),
                     check_visibility::<With<Billboard>>.in_set(CheckVisibility),
                 ),
             );
diff --git a/src/text.rs b/src/text.rs
index 179b976..7ee10c5 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -1,15 +1,16 @@
 use crate::pipeline::{RenderBillboardImage, RenderBillboardMesh};
 use crate::utils::calculate_billboard_uniform;
-use crate::{BillboardDepth, BillboardLockAxis};
+use crate::{BillboardDepth, BillboardLockAxis, BillboardText, BillboardTextNeedsRerender};
 use bevy::color::palettes;
 use bevy::prelude::*;
 use bevy::render::mesh::{Indices, PrimitiveTopology};
 use bevy::render::render_asset::RenderAssetUsages;
+use bevy::render::sync_world::RenderEntity;
 use bevy::render::Extract;
 use bevy::sprite::Anchor;
 use bevy::text::{
-    BreakLineOn, FontAtlasSets, PositionedGlyph, Text2dBounds, TextPipeline, TextSettings,
-    YAxisOrientation,
+    ComputedTextBlock, CosmicFontSystem, FontAtlasSets, PositionedGlyph, SwashCache, TextBounds,
+    TextLayoutInfo, TextPipeline, TextReader, YAxisOrientation,
 };
 use bevy::utils::{HashMap, HashSet};
 use smallvec::SmallVec;
@@ -19,13 +20,14 @@ use smallvec::SmallVec;
 
 #[derive(Component, Copy, Clone, Debug, Reflect, Deref, Default)]
 #[reflect(Component)]
-pub struct BillboardTextBounds(pub Text2dBounds);
+pub struct BillboardTextBounds(pub TextBounds);
 
 // TODO: Maybe use something like { Single(Group), Multi(SmallVec<[Group; 1]>) }, benchmark it
-#[derive(Component, Clone, Debug, Deref, DerefMut, Default)]
+#[derive(Component, Clone, Debug, Deref, DerefMut, Default, Reflect)]
+#[reflect(Component)]
 pub struct BillboardTextHandles(pub SmallVec<[BillboardTextHandleGroup; 1]>);
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, Reflect)]
 pub struct BillboardTextHandleGroup {
     mesh: Handle<Mesh>,
     image: Handle<Image>,
@@ -36,7 +38,7 @@ pub fn extract_billboard_text(
     mut previous_len: Local<usize>,
     billboard_text_query: Extract<
         Query<(
-            Entity,
+            &RenderEntity,
             &ViewVisibility,
             &GlobalTransform,
             &Transform,
@@ -48,7 +50,7 @@ pub fn extract_billboard_text(
 ) {
     let mut batch = Vec::with_capacity(*previous_len);
 
-    for (entity, visibility, global_transform, transform, handles, &depth, lock_axis) in
+    for (render_entity, visibility, global_transform, transform, handles, &depth, lock_axis) in
         &billboard_text_query
     {
         if !visibility.get() {
@@ -58,8 +60,10 @@ pub fn extract_billboard_text(
         let uniform = calculate_billboard_uniform(global_transform, transform, lock_axis);
 
         for handle_group in handles.iter() {
+            // TODO: this will overwrite the render entity if we try to
+            // TODO: add multiple handles in the same extraction!
             batch.push((
-                entity,
+                render_entity.id(),
                 (
                     uniform,
                     RenderBillboardMesh {
@@ -78,52 +82,75 @@ pub fn extract_billboard_text(
     }
 
     *previous_len = batch.len();
-    commands.insert_or_spawn_batch(batch);
+    commands.insert_batch(batch);
 }
 
-pub fn update_billboard_text_layout(
+pub(crate) fn update_billboard_text_layout(
     mut queue: Local<HashSet<Entity>>,
     mut images: ResMut<Assets<Image>>,
     mut meshes: ResMut<Assets<Mesh>>,
     fonts: Res<Assets<Font>>,
-    text_settings: Res<TextSettings>,
     mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
     mut font_atlas_set_storage: ResMut<FontAtlasSets>,
     mut text_pipeline: ResMut<TextPipeline>,
-    mut text_query: Query<(
-        Entity,
-        Ref<Text>,
-        Ref<BillboardTextBounds>,
-        Ref<Anchor>,
-        &mut BillboardTextHandles,
-    )>,
+    mut font_system: ResMut<CosmicFontSystem>,
+    mut swash_cache: ResMut<SwashCache>,
+    mut text_query: Query<
+        (
+            Entity,
+            &mut TextLayoutInfo,
+            Ref<TextLayout>,
+            Ref<BillboardTextBounds>,
+            Ref<Anchor>,
+            &mut BillboardTextHandles,
+            &mut ComputedTextBlock,
+            Has<BillboardTextNeedsRerender>,
+        ),
+        With<BillboardText>,
+    >,
+    mut text_reader: TextReader<BillboardText>,
+    mut commands: Commands,
 ) {
-    const SCALE_FACTOR: f32 = 1.0;
-
-    for (entity, text, bounds, anchor, mut billboard_text_handles) in &mut text_query {
-        if text.is_changed() || bounds.is_changed() || anchor.is_changed() || queue.remove(&entity)
+    const SCALE_FACTOR: f64 = 1.0;
+
+    for (
+        entity,
+        mut info,
+        layout,
+        bounds,
+        anchor,
+        mut handles,
+        mut computed,
+        text_needs_rerender,
+    ) in &mut text_query
+    {
+        if text_needs_rerender
+            || layout.is_changed()
+            || bounds.is_changed()
+            || anchor.is_changed()
+            || computed.needs_rerender()
+            || queue.remove(&entity)
         {
-            let text_bounds = Vec2::new(
-                if text.linebreak_behavior == BreakLineOn::NoWrap {
-                    f32::INFINITY
-                } else {
-                    bounds.size.x
-                },
-                bounds.size.y,
-            );
-
-            let info = match text_pipeline.queue_text(
+            let text_bounds = if layout.linebreak == LineBreak::NoWrap {
+                TextBounds::UNBOUNDED
+            } else {
+                bounds.0
+            };
+
+            match text_pipeline.queue_text(
+                &mut info,
                 &fonts,
-                &text.sections,
+                text_reader.iter(entity),
                 SCALE_FACTOR,
-                text.justify,
-                text.linebreak_behavior,
+                &layout,
                 text_bounds,
                 &mut font_atlas_set_storage,
                 &mut texture_atlases,
                 &mut images,
-                text_settings.as_ref(),
                 YAxisOrientation::BottomToTop,
+                computed.as_mut(),
+                &mut font_system,
+                &mut swash_cache,
             ) {
                 Err(TextError::NoSuchFont) => {
                     error!("Missing font (could still be loading)");
@@ -133,11 +160,18 @@ pub fn update_billboard_text_layout(
                 Err(err @ TextError::FailedToAddGlyph(_)) => {
                     panic!("Fatal error when processing text: {err}.");
                 }
-                Ok(info) => info,
+                Err(err @ TextError::FailedToGetGlyphImage(_)) => {
+                    panic!("Fatal error when processing text: {err}.");
+                }
+                Ok(_) => (),
             };
 
+            commands
+                .entity(entity)
+                .remove::<BillboardTextNeedsRerender>();
+
             let text_anchor = -(anchor.as_vec() + 0.5);
-            let alignment_translation = info.logical_size * text_anchor;
+            let alignment_translation = info.size * text_anchor;
 
             let length = info.glyphs.len();
             let mut textures = HashMap::new();
@@ -162,7 +196,7 @@ pub fn update_billboard_text_layout(
                 entry.0.push(glyph.clone());
             }
 
-            billboard_text_handles.clear();
+            handles.clear();
 
             for (glyphs, (atlas, texture)) in textures.into_values() {
                 let mut positions = Vec::with_capacity(info.glyphs.len() * 4);
@@ -171,13 +205,13 @@ pub fn update_billboard_text_layout(
                 let mut indices = Vec::with_capacity(info.glyphs.len() * 6);
 
                 let mut color = palettes::css::WHITE.to_f32_array();
-                let mut current_section = usize::MAX;
+                let mut current_span = usize::MAX;
 
                 for PositionedGlyph {
                     position,
                     size,
                     atlas_info,
-                    section_index,
+                    span_index,
                     ..
                 } in glyphs
                 {
@@ -195,7 +229,7 @@ pub fn update_billboard_text_layout(
                         [bottom_right.x, top_left.y, 0.0],
                     ]);
 
-                    let URect { min, max } = atlas.textures[atlas_info.glyph_index];
+                    let URect { min, max } = atlas.textures[atlas_info.location.glyph_index];
                     let atlas_size = atlas.size.as_vec2();
                     let min = min.as_vec2() / atlas_size;
                     let max = max.as_vec2() / atlas_size;
@@ -207,13 +241,13 @@ pub fn update_billboard_text_layout(
                         [max.x, max.y],
                     ]);
 
-                    if section_index != current_section {
-                        color = text.sections[section_index]
-                            .style
-                            .color
+                    if span_index != current_span {
+                        color = text_reader
+                            .get_color(entity, span_index)
+                            .unwrap()
                             .to_linear()
                             .to_f32_array();
-                        current_section = section_index;
+                        current_span = span_index;
                     }
 
                     colors.extend([color, color, color, color]);
@@ -223,7 +257,7 @@ pub fn update_billboard_text_layout(
 
                 let mut mesh = Mesh::new(
                     PrimitiveTopology::TriangleList,
-                    RenderAssetUsages::default(),
+                    RenderAssetUsages::RENDER_WORLD,
                 );
 
                 mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
@@ -232,7 +266,7 @@ pub fn update_billboard_text_layout(
 
                 mesh.insert_indices(Indices::U32(indices));
 
-                billboard_text_handles.push(BillboardTextHandleGroup {
+                handles.push(BillboardTextHandleGroup {
                     mesh: meshes.add(mesh),
                     image: texture,
                 });
@@ -241,6 +275,57 @@ pub fn update_billboard_text_layout(
     }
 }
 
+/// Similar implementation to [`bevy::text::detect_text_needs_rerender`], but checks
+/// for changed colors on root text components or child span components.
+pub(crate) fn detect_billboard_text_color_change(
+    changed_roots: Query<Entity, (Changed<TextColor>, With<BillboardText>)>,
+    changed_spans: Query<&Parent, (Changed<TextColor>, With<TextSpan>)>,
+    mut computed: Query<(
+        Entity,
+        Option<&Parent>,
+        Has<ComputedTextBlock>,
+        Has<TextSpan>,
+    )>,
+    mut commands: Commands,
+) {
+    // TODO: ideally, we can set needs_rerender of `ComputedTextBlock`, but it is
+    // private, so we use our own marker component.
+
+    // check for root changes
+    for root in &changed_roots {
+        let Some(mut ent) = commands.get_entity(root) else {
+            continue;
+        };
+        ent.insert(BillboardTextNeedsRerender);
+    }
+
+    // check for span changes
+    for span_parent in &changed_spans {
+        let mut parent: Entity = **span_parent;
+
+        loop {
+            let Ok((ent, maybe_parent, has_computed, has_span)) = computed.get_mut(parent) else {
+                break;
+            };
+
+            if has_computed {
+                commands.entity(ent).insert(BillboardTextNeedsRerender);
+                break;
+            }
+
+            if !has_span {
+                break;
+            }
+
+            let Some(next_parent) = maybe_parent else {
+                break;
+            };
+
+            parent = **next_parent;
+        }
+    }
+}
+
 // TODO: Use EntityHash with EntityHashMap in 0.12 for extracted.
 // The related code is removed, but this todo is helpful for future.
 
diff --git a/src/texture.rs b/src/texture.rs
index c803eee..f0acf12 100644
--- a/src/texture.rs
+++ b/src/texture.rs
@@ -1,9 +1,6 @@
 use bevy::{
-    ecs::{
-        entity::Entity,
-        system::{Commands, Local, Query},
-    },
-    render::{view::ViewVisibility, Extract},
+    ecs::system::{Commands, Local, Query},
+    render::{sync_world::RenderEntity, view::ViewVisibility, Extract},
     transform::components::{GlobalTransform, Transform},
 };
 
@@ -11,7 +8,7 @@ use crate::{
     pipeline::{RenderBillboardImage, RenderBillboardMesh},
     text::RenderBillboard,
     utils::calculate_billboard_uniform,
-    BillboardDepth, BillboardLockAxis, BillboardMeshHandle, BillboardTextureHandle,
+    BillboardDepth, BillboardLockAxis, BillboardMesh, BillboardTexture,
 };
 
 pub fn extract_billboard_texture(
@@ -19,12 +16,12 @@ pub fn extract_billboard_texture(
     mut previous_len: Local<usize>,
     billboard_text_query: Extract<
         Query<(
-            Entity,
+            &RenderEntity,
             &ViewVisibility,
             &GlobalTransform,
             &Transform,
-            &BillboardMeshHandle,
-            &BillboardTextureHandle,
+            &BillboardMesh,
+            &BillboardTexture,
             &BillboardDepth,
             Option<&BillboardLockAxis>,
         )>,
@@ -33,7 +30,7 @@ pub fn extract_billboard_texture(
     let mut batch = Vec::with_capacity(*previous_len);
 
     for (
-        entity,
+        render_entity,
         visibility,
         global_transform,
         transform,
@@ -50,7 +47,7 @@ pub fn extract_billboard_texture(
         let uniform = calculate_billboard_uniform(global_transform, transform, lock_axis);
 
         batch.push((
-            entity,
+            render_entity.id(),
             (
                 uniform,
                 RenderBillboardMesh {
@@ -68,5 +65,5 @@ pub fn extract_billboard_texture(
     }
 
     *previous_len = batch.len();
-    commands.insert_or_spawn_batch(batch);
+    commands.insert_batch(batch);
 }
diff --git a/tests/text_usage.rs b/tests/text_usage.rs
index de88459..8b7a638 100644
--- a/tests/text_usage.rs
+++ b/tests/text_usage.rs
@@ -6,21 +6,17 @@ use bevy_mod_billboard::prelude::*;
 fn text_binding_compatible_with_ui() {
     fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
         let fira_sans_regular_handle = asset_server.load("FiraSans-Regular.ttf");
+        let text_font = TextFont::from_font(fira_sans_regular_handle).with_font_size(60.0);
 
-        let style = TextStyle {
-            font: fira_sans_regular_handle.clone(),
-            font_size: 60.0,
-            color: Color::WHITE,
-        };
+        commands.spawn(Camera3d::default());
 
-        commands.spawn(Camera3dBundle::default());
+        commands.spawn((
+            BillboardText::new("a"),
+            text_font.clone(),
+            TextColor::from(Color::WHITE),
+        ));
 
-        commands.spawn(BillboardTextBundle {
-            text: Text::from_section("a", style.clone()),
-            ..default()
-        });
-
-        commands.spawn(TextBundle::from_section("b", style));
+        commands.spawn((Text::new("b"), text_font, TextColor::from(Color::WHITE)));
     }
 
     App::new()