diff --git a/Cargo.toml b/Cargo.toml
index 1d247d4..9afe1d6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,7 +18,11 @@ exclude = ["examples/*.gif", ".github", "release.md", "run_examples.bat"]
 [features]
 default = ["bevy_sprite", "bevy_ui", "bevy_text"]
 # Enable built-in lenses for Bevy sprites
-bevy_sprite = ["bevy/bevy_sprite", "bevy/bevy_render"]
+bevy_sprite = [
+    "bevy/bevy_sprite",
+    "bevy/bevy_render",
+    "bevy/bevy_sprite_render",
+]
 # Enable built-in lenses for Bevy UI
 bevy_ui = ["bevy/bevy_ui", "bevy/bevy_render"]
 # Enable built-in lenses for Bevy Text
@@ -26,23 +30,45 @@ bevy_text = ["bevy/bevy_text", "bevy/bevy_render", "bevy/bevy_sprite"]
 
 [dependencies]
 # Note: abuse 'bevy_color' to force 'bevy_math/curve' feature, which defines EaseFunction
-bevy = { version = "0.16", default-features = false, features = [ "bevy_color", "bevy_asset", "bevy_log" ]}
+bevy = { version = "0.17", default-features = false, features = [
+    "bevy_color",
+    "bevy_asset",
+    "bevy_log",
+] }
 thiserror = "2"
 
 [dev-dependencies]
-bevy-inspector-egui = { version = "0.31" }
+bevy-inspector-egui = { version = "0.34" }
 
 [[example]]
 name = "ambient_light"
-required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking", "bevy/bevy_pbr", "bevy/hdr", "bevy/tonemapping_luts"]
+required-features = [
+    "bevy_ui",
+    "bevy_text",
+    "bevy/bevy_winit",
+    "bevy/bevy_picking",
+    "bevy/bevy_pbr",
+    "bevy/hdr",
+    "bevy/tonemapping_luts",
+]
 
 [[example]]
 name = "follow"
-required-features = ["bevy_sprite", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking"]
+required-features = [
+    "bevy_sprite",
+    "bevy_text",
+    "bevy/bevy_winit",
+    "bevy/bevy_picking",
+]
 
 [[example]]
 name = "menu"
-required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking"]
+required-features = [
+    "bevy_ui",
+    "bevy_text",
+    "bevy/bevy_winit",
+    "bevy/bevy_picking",
+]
 
 [[example]]
 name = "colormaterial_color"
@@ -62,15 +88,30 @@ required-features = ["bevy_sprite", "bevy/bevy_winit", "bevy/bevy_picking"]
 
 [[example]]
 name = "ui_position"
-required-features = ["bevy_sprite", "bevy_ui", "bevy/bevy_winit", "bevy/bevy_picking"]
+required-features = [
+    "bevy_sprite",
+    "bevy_ui",
+    "bevy/bevy_winit",
+    "bevy/bevy_picking",
+]
 
 [[example]]
 name = "text_color"
-required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking"]
+required-features = [
+    "bevy_ui",
+    "bevy_text",
+    "bevy/bevy_winit",
+    "bevy/bevy_picking",
+]
 
 [[example]]
 name = "sequence"
-required-features = ["bevy_sprite", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking"]
+required-features = [
+    "bevy_sprite",
+    "bevy_text",
+    "bevy/bevy_winit",
+    "bevy/bevy_picking",
+]
 
 [workspace]
 resolver = "2"
diff --git a/benchmarks/Cargo.toml b/benchmarks/Cargo.toml
index c98da5a..ee5dacf 100644
--- a/benchmarks/Cargo.toml
+++ b/benchmarks/Cargo.toml
@@ -18,7 +18,7 @@ criterion = { version = "0.5", features = ["html_reports"] }
 bevy_tweening = { path = "../" }
 
 [dependencies.bevy]
-version = "0.16"
+version = "0.17"
 default-features = false
 features = ["bevy_render", "bevy_sprite", "bevy_text", "bevy_ui"]
 
diff --git a/src/lib.rs b/src/lib.rs
index 4683e12..3d3102a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1712,7 +1712,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
 }
 
 /// Event raised when a [`TweenAnim`] completed.
-#[derive(Debug, Clone, Copy, Event)]
+#[derive(Debug, Clone, Copy, Event, Message)]
 pub struct AnimCompletedEvent {
     /// The entity owning the [`TweenAnim`] which completed.
     ///
@@ -2231,9 +2231,9 @@ impl TweenAnim {
         let mut to_remove = Vec::with_capacity(anims.len());
         world.resource_scope(|world, resolver: Mut<TweenResolver>| {
             world.resource_scope(
-                |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                |world, mut cycle_events: Mut<Messages<CycleCompletedEvent>>| {
                     world.resource_scope(
-                        |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                        |world, mut anim_events: Mut<Messages<AnimCompletedEvent>>| {
                             let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
                             for (
                                 anim_entity,
@@ -2383,8 +2383,8 @@ impl TweenAnim {
         target_kind: &AnimTargetKind,
         mut mut_untyped: MutUntyped,
         target_type_id: &TypeId,
-        mut cycle_events: Mut<Events<CycleCompletedEvent>>,
-        mut anim_events: Mut<Events<AnimCompletedEvent>>,
+        mut cycle_events: Mut<Messages<CycleCompletedEvent>>,
+        mut anim_events: Mut<Messages<AnimCompletedEvent>>,
     ) -> Result<StepResult, TweeningError> {
         let mut completed_events = Vec::with_capacity(8);
 
@@ -2435,10 +2435,13 @@ impl TweenAnim {
         if !completed_events.is_empty() {
             for event in completed_events.drain(..) {
                 // Send buffered event
-                cycle_events.send(event);
+                cycle_events.write(event);
 
                 // Trigger all entity-scoped observers
-                commands.trigger_targets(event, anim_entity);
+                commands.trigger(CycleCompletedEvent {
+                    anim_entity,
+                    ..event
+                });
             }
         }
 
@@ -2450,10 +2453,10 @@ impl TweenAnim {
             };
 
             // Send buffered event
-            anim_events.send(event);
+            anim_events.write(event);
 
             // Trigger all entity-scoped observers
-            commands.trigger_targets(event, anim_entity);
+            commands.trigger(event);
         }
 
         let ret = StepResult {
@@ -2555,8 +2558,8 @@ type ResourceResolver = Box<
             Entity,
             &TypeId,
             Duration,
-            Mut<Events<CycleCompletedEvent>>,
-            Mut<Events<AnimCompletedEvent>>,
+            Mut<Messages<CycleCompletedEvent>>,
+            Mut<Messages<AnimCompletedEvent>>,
         ) -> Result<bool, TweeningError>
         + Send
         + Sync
@@ -2570,8 +2573,8 @@ type AssetResolver = Box<
             Entity,
             &TypeId,
             Duration,
-            Mut<Events<CycleCompletedEvent>>,
-            Mut<Events<AnimCompletedEvent>>,
+            Mut<Messages<CycleCompletedEvent>>,
+            Mut<Messages<AnimCompletedEvent>>,
         ) -> Result<bool, TweeningError>
         + Send
         + Sync
@@ -2619,8 +2622,8 @@ impl TweenResolver {
                         entity: Entity,
                         target_type_id: &TypeId,
                         delta_time: Duration,
-                        mut cycle_events: Mut<Events<CycleCompletedEvent>>,
-                        mut anim_events: Mut<Events<AnimCompletedEvent>>|
+                        mut cycle_events: Mut<Messages<CycleCompletedEvent>>,
+                        mut anim_events: Mut<Messages<AnimCompletedEvent>>|
          -> Result<bool, TweeningError> {
             // First, remove the resource R from the world so we can access it mutably in
             // parallel of the TweenAnim
@@ -2667,8 +2670,8 @@ impl TweenResolver {
                         entity: Entity,
                         target_type_id: &TypeId,
                         delta_time: Duration,
-                        mut cycle_events: Mut<Events<CycleCompletedEvent>>,
-                        mut anim_events: Mut<Events<AnimCompletedEvent>>|
+                        mut cycle_events: Mut<Messages<CycleCompletedEvent>>,
+                        mut anim_events: Mut<Messages<AnimCompletedEvent>>|
          -> Result<bool, TweeningError> {
             let asset_id = asset_id.typed::<A>();
             // First, remove the Assets<A> from the world so we can access it mutably in
@@ -2726,8 +2729,8 @@ impl TweenResolver {
         resource_id: ComponentId,
         entity: Entity,
         delta_time: Duration,
-        cycle_events: Mut<Events<CycleCompletedEvent>>,
-        anim_events: Mut<Events<AnimCompletedEvent>>,
+        cycle_events: Mut<Messages<CycleCompletedEvent>>,
+        anim_events: Mut<Messages<AnimCompletedEvent>>,
     ) -> Result<bool, TweeningError> {
         let Some(resolver) = self.resource_resolver.get(&resource_id) else {
             println!("ERROR: resource not registered {:?}", resource_id);
@@ -2753,8 +2756,8 @@ impl TweenResolver {
         untyped_asset_id: UntypedAssetId,
         entity: Entity,
         delta_time: Duration,
-        cycle_events: Mut<Events<CycleCompletedEvent>>,
-        anim_events: Mut<Events<AnimCompletedEvent>>,
+        cycle_events: Mut<Messages<CycleCompletedEvent>>,
+        anim_events: Mut<Messages<AnimCompletedEvent>>,
     ) -> Result<bool, TweeningError> {
         let Some(resolver) = self.asset_resolver.get(&resource_id) else {
             println!("ERROR: asset not registered {:?}", resource_id);
@@ -3118,7 +3121,7 @@ mod tests {
         );
 
         fn observe_global(
-            _trigger: Trigger<CycleCompletedEvent>,
+            _trigger: On<CycleCompletedEvent>,
             mut count: ResMut<Count<CycleCompletedEvent, GlobalMarker>>,
         ) {
             count.count += 1;
@@ -3126,7 +3129,7 @@ mod tests {
         env.world.add_observer(observe_global);
 
         fn observe_entity(
-            _trigger: Trigger<CycleCompletedEvent>,
+            _trigger: On<CycleCompletedEvent>,
             mut count: ResMut<Count<CycleCompletedEvent>>,
         ) {
             count.count += 1;
@@ -3798,9 +3801,9 @@ mod tests {
         env.world
             .resource_scope(|world, resolver: Mut<TweenResolver>| {
                 world.resource_scope(
-                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                    |world, mut cycle_events: Mut<Messages<CycleCompletedEvent>>| {
                         world.resource_scope(
-                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                            |world, mut anim_events: Mut<Messages<AnimCompletedEvent>>| {
                                 assert!(resolver
                                     .resolve_resource(
                                         world,
@@ -3828,9 +3831,9 @@ mod tests {
         env.world
             .resource_scope(|world, resolver: Mut<TweenResolver>| {
                 world.resource_scope(
-                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                    |world, mut cycle_events: Mut<Messages<CycleCompletedEvent>>| {
                         world.resource_scope(
-                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                            |world, mut anim_events: Mut<Messages<AnimCompletedEvent>>| {
                                 assert!(resolver
                                     .resolve_resource(
                                         world,
@@ -3880,9 +3883,9 @@ mod tests {
         env.world
             .resource_scope(|world, resolver: Mut<TweenResolver>| {
                 world.resource_scope(
-                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                    |world, mut cycle_events: Mut<Messages<CycleCompletedEvent>>| {
                         world.resource_scope(
-                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                            |world, mut anim_events: Mut<Messages<AnimCompletedEvent>>| {
                                 assert!(resolver
                                     .resolve_asset(
                                         world,
@@ -3911,9 +3914,9 @@ mod tests {
         env.world
             .resource_scope(|world, resolver: Mut<TweenResolver>| {
                 world.resource_scope(
-                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                    |world, mut cycle_events: Mut<Messages<CycleCompletedEvent>>| {
                         world.resource_scope(
-                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                            |world, mut anim_events: Mut<Messages<AnimCompletedEvent>>| {
                                 assert!(resolver
                                     .resolve_asset(
                                         world,
diff --git a/src/plugin.rs b/src/plugin.rs
index 418ac5c..72aea92 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -25,8 +25,8 @@ pub struct TweeningPlugin;
 impl Plugin for TweeningPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<TweenResolver>()
-            .add_event::<CycleCompletedEvent>()
-            .add_event::<AnimCompletedEvent>()
+            .add_message::<CycleCompletedEvent>()
+            .add_message::<AnimCompletedEvent>()
             .add_systems(
                 Update,
                 animator_system.in_set(AnimationSystem::AnimationUpdate),
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 04edcea..d7a6519 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -5,7 +5,7 @@ use bevy::{
         change_detection::DetectChanges as _,
         component::{Component, Mutable},
         entity::Entity,
-        event::{Event, Events},
+        message::{Message, Messages},
         system::{IntoSystem, System},
         world::{Mut, World},
     },
@@ -134,8 +134,8 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
     pub fn new(tweenable: impl Tweenable + 'static) -> Self {
         let mut world = World::new();
         world.init_resource::<Time>();
-        world.init_resource::<Events<CycleCompletedEvent>>();
-        world.init_resource::<Events<AnimCompletedEvent>>();
+        world.init_resource::<Messages<CycleCompletedEvent>>();
+        world.init_resource::<Messages<AnimCompletedEvent>>();
         world.init_resource::<TweenResolver>();
 
         let mut system = IntoSystem::into_system(crate::plugin::animator_system);
@@ -154,8 +154,8 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
     pub fn empty() -> Self {
         let mut world = World::new();
         world.init_resource::<Time>();
-        world.init_resource::<Events<CycleCompletedEvent>>();
-        world.init_resource::<Events<AnimCompletedEvent>>();
+        world.init_resource::<Messages<CycleCompletedEvent>>();
+        world.init_resource::<Messages<AnimCompletedEvent>>();
         world.init_resource::<TweenResolver>();
 
         let mut system = IntoSystem::into_system(crate::plugin::animator_system);
@@ -187,12 +187,12 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
         }
 
         // Tick system
-        self.system.run((), &mut self.world);
+        let _ = self.system.run((), &mut self.world);
 
         // Update events after system ticked, in case system emitted some events
-        let mut events = self.world.resource_mut::<Events<CycleCompletedEvent>>();
+        let mut events = self.world.resource_mut::<Messages<CycleCompletedEvent>>();
         events.update();
-        let mut events = self.world.resource_mut::<Events<AnimCompletedEvent>>();
+        let mut events = self.world.resource_mut::<Messages<AnimCompletedEvent>>();
         events.update();
     }
 
@@ -217,8 +217,8 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
     }
 
     /// Get the emitted event count since last tick.
-    pub fn event_count<E: Event>(&self) -> usize {
-        let events = self.world.resource::<Events<E>>();
+    pub fn event_count<E: Message>(&self) -> usize {
+        let events = self.world.resource::<Messages<E>>();
         events.get_cursor().len(events)
     }
 }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 75bc029..f426d81 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -106,7 +106,7 @@ pub enum TweenState {
 /// that the tweenable has finished stepping and do not need to be updated
 /// anymore, a state which is never reached for looping animation. Here the
 /// [`CycleCompletedEvent`] instead marks the end of a single cycle.
-#[derive(Copy, Clone, Event)]
+#[derive(Copy, Clone, EntityEvent, Message)]
 pub struct CycleCompletedEvent {
     /// The entity owning the tweenable animation which completed.
     ///
@@ -114,6 +114,7 @@ pub struct CycleCompletedEvent {
     /// which completed is part of.
     ///
     /// [`TweenAnim`]: crate::TweenAnim
+    #[event_target]
     pub anim_entity: Entity,
     /// The target the tweenable which completed and the [`TweenAnim`] it's
     /// part of are mutating. Note that an actual [`AnimTarget`] component might
@@ -1333,7 +1334,7 @@ impl Delay {
 
     /// Check if the delay completed.
     pub fn is_completed(&self) -> bool {
-        self.timer.finished()
+        self.timer.is_finished()
     }
 
     /// Get the current tweenable state.
@@ -1356,7 +1357,7 @@ impl Tweenable for Delay {
     }
 
     fn set_elapsed(&mut self, elapsed: Duration) {
-        // need to reset() to clear finished() unfortunately
+        // need to reset() to clear is_finished() unfortunately
         self.timer.reset();
         self.timer.set_elapsed(elapsed);
         // set_elapsed() does not update finished() etc. which we rely on
@@ -1417,9 +1418,7 @@ mod tests {
 
     use std::ops::{Deref as _, DerefMut as _};
 
-    use bevy::ecs::{
-        change_detection::MaybeLocation, component::Tick, event::Events, system::SystemState,
-    };
+    use bevy::ecs::{change_detection::MaybeLocation, component::Tick, system::SystemState};
 
     use super::*;
     use crate::{lens::*, test_utils::assert_approx_eq};
@@ -1552,7 +1551,7 @@ mod tests {
     /// Utility to create a test environment to tick a tween.
     fn make_test_env() -> (World, Entity) {
         let mut world = World::new();
-        world.init_resource::<Events<CycleCompletedEvent>>();
+        world.init_resource::<Messages<CycleCompletedEvent>>();
         let entity = world.spawn(Transform::default()).id();
         (world, entity)
     }
@@ -1568,13 +1567,13 @@ mod tests {
         // Tick the given tween and apply its state to the given entity target
         let target_type_id = TypeId::of::<Transform>();
         let ret = world.resource_scope(
-            |world: &mut World, mut events: Mut<Events<CycleCompletedEvent>>| {
+            |world: &mut World, mut events: Mut<Messages<CycleCompletedEvent>>| {
                 let component_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
                 if let Ok(mut target) = entity_mut.get_mut_by_id(component_id) {
                     let world_target = AnimTargetKind::Component { entity };
                     let mut notify_completed = || {
-                        events.send(CycleCompletedEvent {
+                        events.write(CycleCompletedEvent {
                             anim_entity,
                             target: world_target,
                         });
@@ -1594,7 +1593,7 @@ mod tests {
 
         // Propagate events
         {
-            let mut events = world.resource_mut::<Events<CycleCompletedEvent>>();
+            let mut events = world.resource_mut::<Messages<CycleCompletedEvent>>();
             events.update();
         }
 
@@ -1705,7 +1704,7 @@ mod tests {
                 }
 
                 let (mut world, entity) = make_test_env();
-                let mut event_reader_system_state: SystemState<EventReader<CycleCompletedEvent>> =
+                let mut event_reader_system_state: SystemState<MessageReader<CycleCompletedEvent>> =
                     SystemState::new(&mut world);
 
                 // Loop over 2.2 seconds, so greater than one ping-pong loop (2 cycles in
@@ -1932,7 +1931,7 @@ mod tests {
                     assert_approx_eq!(expected_translation, transform.translation, 1e-5);
                     assert_approx_eq!(Quat::IDENTITY, transform.rotation, 1e-5);
 
-                    // Events are only sent when playing forward
+                    // Messages are only sent when playing forward
                     if playback_direction.is_forward() {
                         //let component_id = world.component_id::<Transform>().unwrap();
                         let mut event_reader = event_reader_system_state.get_mut(&mut world);