diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index f2d5da4cd7dbf..58ca8028033bc 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -13,9 +13,11 @@ keywords = ["bevy"]
 bevy_app = { path = "../bevy_app", version = "0.12.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.12.0" }
 bevy_core = { path = "../bevy_core", version = "0.12.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0" }
 bevy_math = { path = "../bevy_math", version = "0.12.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.12.0", features = [
   "bevy",
+  "petgraph",
 ] }
 bevy_render = { path = "../bevy_render", version = "0.12.0" }
 bevy_time = { path = "../bevy_time", version = "0.12.0" }
@@ -24,5 +26,8 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.12.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.12.0" }
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0" }
 
+# other
+petgraph = "0.6"
+
 [lints]
 workspace = true
diff --git a/crates/bevy_animation/src/graph.rs b/crates/bevy_animation/src/graph.rs
new file mode 100644
index 0000000000000..e84294bc4bfb6
--- /dev/null
+++ b/crates/bevy_animation/src/graph.rs
@@ -0,0 +1,467 @@
+//! The animation graph.
+
+#![allow(missing_docs)]
+
+use std::ops::{Index, IndexMut, Mul};
+
+use bevy_asset::{Assets, Handle};
+use bevy_core::Name;
+use bevy_derive::Deref;
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    query::Has,
+    reflect::ReflectComponent,
+    system::{Query, Res},
+};
+use bevy_hierarchy::{Children, Parent};
+use bevy_reflect::Reflect;
+use bevy_render::mesh::morph::MorphWeights;
+use bevy_time::Time;
+use bevy_transform::components::Transform;
+use petgraph::{
+    stable_graph::{NodeIndex, StableDiGraph},
+    visit::{IntoNodeReferences, NodeRef},
+    Direction,
+};
+
+use crate::{AnimationClip, AnimationPlayer, PlayingAnimation, RepeatAnimation};
+
+#[derive(Component, Reflect)]
+#[reflect(Component)]
+pub struct AnimationGraph {
+    graph: StableDiGraph<AnimationNode, ()>,
+    root: AnimationNodeIndex,
+}
+
+#[derive(Clone, Copy, Deref, Reflect)]
+pub struct AnimationWeight(f32);
+
+#[derive(Clone, Reflect)]
+pub struct AnimationNode {
+    animation: Option<PlayingAnimation>,
+    pub paused: bool,
+    pub weight: AnimationWeight,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Deref, Reflect)]
+pub struct AnimationNodeIndex(NodeIndex<u32>);
+
+struct AnimationContext<
+    'gr,
+    't,
+    'ac,
+    'p,
+    'ppq,
+    'ppa,
+    'ppb,
+    'ppc,
+    'cq,
+    'ca,
+    'cb,
+    'cc,
+    'nq,
+    'na,
+    'nb,
+    'nc,
+    'tq,
+    'ta,
+    'tb,
+    'tc,
+    'mwq,
+    'mwa,
+    'mwb,
+    'mwc,
+> {
+    animation_graph: &'gr mut AnimationGraph,
+    time: &'t Time,
+    root_entity: Entity,
+    animation_clips: &'ac Assets<AnimationClip>,
+    parent: Option<&'p Parent>,
+    parents: &'ppq Query<
+        'ppa,
+        'ppb,
+        (
+            Has<AnimationPlayer>,
+            Has<AnimationGraph>,
+            Option<&'ppc Parent>,
+        ),
+    >,
+    children: &'cq Query<'ca, 'cb, &'cc Children>,
+
+    // TODO: These should be abstracted into a list of `Animatable` properties.
+    names: &'nq Query<'na, 'nb, &'nc Name>,
+    transforms: &'tq Query<'ta, 'tb, &'tc mut Transform>,
+    morph_weights: &'mwq Query<'mwa, 'mwb, &'mwc mut MorphWeights>,
+}
+
+impl<
+        'gr,
+        't,
+        'ac,
+        'p,
+        'ppq,
+        'ppa,
+        'ppb,
+        'ppc,
+        'cq,
+        'ca,
+        'cb,
+        'cc,
+        'nq,
+        'na,
+        'nb,
+        'nc,
+        'tq,
+        'ta,
+        'tb,
+        'tc,
+        'mwq,
+        'mwa,
+        'mwb,
+        'mwc,
+    >
+    AnimationContext<
+        'gr,
+        't,
+        'ac,
+        'p,
+        'ppq,
+        'ppa,
+        'ppb,
+        'ppc,
+        'cq,
+        'ca,
+        'cb,
+        'cc,
+        'nq,
+        'na,
+        'nb,
+        'nc,
+        'tq,
+        'ta,
+        'tb,
+        'tc,
+        'mwq,
+        'mwa,
+        'mwb,
+        'mwc,
+    >
+{
+    fn evaluate(&mut self) {
+        self.evaluate_node(self.animation_graph.root, AnimationWeight(1.0))
+    }
+
+    fn evaluate_node(&mut self, node_index: AnimationNodeIndex, weight: AnimationWeight) {
+        let kids: Vec<_> = self
+            .animation_graph
+            .graph
+            .neighbors_directed(*node_index, Direction::Outgoing)
+            .collect();
+        for &kid in &kids {
+            // FIXME: Is `weight * kid_edge.weight()` right?
+            self.evaluate_node(kid.into(), weight * self.animation_graph.graph[kid].weight);
+        }
+
+        let node = &mut self.animation_graph.graph[*node_index];
+        if let Some(ref mut playing_animation) = node.animation {
+            crate::apply_animation(
+                *weight,
+                playing_animation,
+                node.paused,
+                self.root_entity,
+                self.time,
+                self.animation_clips,
+                self.names,
+                self.transforms,
+                self.morph_weights,
+                self.parent,
+                self.parents,
+                self.children,
+            )
+        }
+    }
+}
+
+impl From<NodeIndex<u32>> for AnimationNodeIndex {
+    fn from(value: NodeIndex<u32>) -> Self {
+        Self(value)
+    }
+}
+
+impl Into<NodeIndex<u32>> for AnimationNodeIndex {
+    fn into(self) -> NodeIndex<u32> {
+        *self
+    }
+}
+
+impl From<f32> for AnimationWeight {
+    fn from(value: f32) -> Self {
+        Self(value)
+    }
+}
+
+impl Mul<AnimationWeight> for AnimationWeight {
+    type Output = AnimationWeight;
+
+    fn mul(self, rhs: AnimationWeight) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}
+
+/// A system that updates all playing animations in animation graphs.
+pub fn evaluate_animation_graphs(
+    time: Res<Time>,
+    animation_clips: Res<Assets<AnimationClip>>,
+    children: Query<&Children>,
+    names: Query<&Name>,
+    transforms: Query<&mut Transform>,
+    morph_weights: Query<&mut MorphWeights>,
+    parents: Query<(Has<AnimationPlayer>, Has<AnimationGraph>, Option<&Parent>)>,
+    mut animation_graphs: Query<(Entity, Option<&Parent>, &mut AnimationGraph)>,
+) {
+    for (root_entity, parent, mut animation_graph) in animation_graphs.iter_mut() {
+        // TODO: Update transitions.
+        AnimationContext {
+            animation_graph: &mut animation_graph,
+            time: &time,
+            root_entity,
+            animation_clips: &animation_clips,
+            parent,
+            parents: &parents,
+            children: &children,
+            names: &names,
+            transforms: &transforms,
+            morph_weights: &morph_weights,
+        }
+        .evaluate()
+    }
+}
+
+impl AnimationGraph {
+    pub fn new() -> AnimationGraph {
+        Self::default()
+    }
+
+    pub fn from_clip(
+        animation_clip: Handle<AnimationClip>,
+    ) -> (AnimationGraph, AnimationNodeIndex) {
+        let mut graph = AnimationGraph::new();
+        let node = graph.add_clip_node_from(graph.root, animation_clip);
+        (graph, node)
+    }
+
+    pub fn add_blend_node(&mut self) -> AnimationNodeIndex {
+        self.graph.add_node(AnimationNode::new_blend()).into()
+    }
+
+    pub fn add_clip_node(&mut self, animation_clip: Handle<AnimationClip>) -> AnimationNodeIndex {
+        self.graph
+            .add_node(AnimationNode::new_clip(PlayingAnimation {
+                animation_clip,
+                ..Default::default()
+            }))
+            .into()
+    }
+
+    pub fn add_blend_node_from(&mut self, from: AnimationNodeIndex) -> AnimationNodeIndex {
+        let node = self.add_blend_node();
+        self.add_edge(from, node);
+        node
+    }
+
+    pub fn add_clip_node_from(
+        &mut self,
+        from: AnimationNodeIndex,
+        animation_clip: Handle<AnimationClip>,
+    ) -> AnimationNodeIndex {
+        let node = self.add_clip_node(animation_clip);
+        self.add_edge(from, node);
+        node
+    }
+
+    pub fn add_edge(&mut self, from: AnimationNodeIndex, to: AnimationNodeIndex) -> &mut Self {
+        self.graph.add_edge(from.into(), to.into(), ());
+        self
+    }
+
+    pub fn get_node(&self, index: AnimationNodeIndex) -> Option<&AnimationNode> {
+        self.graph.node_weight(*index)
+    }
+
+    pub fn get_node_mut(&mut self, index: AnimationNodeIndex) -> Option<&mut AnimationNode> {
+        self.graph.node_weight_mut(*index)
+    }
+
+    pub fn root_node(&self) -> AnimationNodeIndex {
+        self.root
+    }
+
+    pub fn nodes(&self) -> impl Iterator<Item = AnimationNodeIndex> + '_ {
+        self.graph
+            .node_references()
+            .map(|reference| AnimationNodeIndex(reference.id()))
+    }
+}
+
+impl Index<AnimationNodeIndex> for AnimationGraph {
+    type Output = AnimationNode;
+
+    fn index(&self, index: AnimationNodeIndex) -> &Self::Output {
+        self.get_node(index)
+            .expect("Animation node not found in this graph")
+    }
+}
+
+impl IndexMut<AnimationNodeIndex> for AnimationGraph {
+    fn index_mut(&mut self, index: AnimationNodeIndex) -> &mut Self::Output {
+        self.get_node_mut(index)
+            .expect("Animation node not found in this graph")
+    }
+}
+
+impl AnimationNode {
+    // Note that these don't start paused by default, to avoid confusion with the root node.
+    fn new_blend() -> AnimationNode {
+        AnimationNode {
+            animation: None,
+            paused: false,
+            weight: AnimationWeight(1.0),
+        }
+    }
+
+    fn new_clip(animation: PlayingAnimation) -> AnimationNode {
+        AnimationNode {
+            animation: Some(animation),
+            paused: true,
+            weight: AnimationWeight(1.0),
+        }
+    }
+
+    #[doc(alias = "resume")]
+    pub fn play(&mut self) -> &mut Self {
+        self.set_paused(false)
+    }
+
+    pub fn pause(&mut self) -> &mut Self {
+        self.set_paused(true)
+    }
+
+    pub fn set_paused(&mut self, paused: bool) -> &mut Self {
+        self.paused = paused;
+        self
+    }
+
+    #[doc(alias = "is_paused")]
+    pub fn paused(&self) -> bool {
+        self.paused
+    }
+
+    pub fn weight(&self) -> AnimationWeight {
+        self.weight
+    }
+
+    pub fn set_weight<W>(&mut self, new_weight: W) -> &mut Self
+    where
+        W: Into<AnimationWeight>,
+    {
+        self.weight = new_weight.into();
+        self
+    }
+
+    pub fn repeat_mode(&self) -> RepeatAnimation {
+        self.animation
+            .as_ref()
+            .expect("Only animation clips can repeat")
+            .repeat
+    }
+
+    #[doc(alias = "set_repeat")]
+    pub fn set_repeat_mode(&mut self, repeat_mode: RepeatAnimation) -> &mut Self {
+        self.animation
+            .as_mut()
+            .expect("Only animation clips can repeat")
+            .repeat = repeat_mode;
+        self
+    }
+
+    pub fn repeat_forever(&mut self) -> &mut Self {
+        self.set_repeat_mode(RepeatAnimation::Forever)
+    }
+
+    pub fn repeat_n(&mut self, count: u32) -> &mut Self {
+        self.set_repeat_mode(RepeatAnimation::Count(count))
+    }
+
+    pub fn no_repeat(&mut self) -> &mut Self {
+        self.set_repeat_mode(RepeatAnimation::Never)
+    }
+
+    pub fn speed(&self) -> f32 {
+        self.animation
+            .as_ref()
+            .expect("Only animation clips have a speed")
+            .speed
+    }
+
+    pub fn set_speed(&mut self, speed: f32) -> &mut Self {
+        self.animation
+            .as_mut()
+            .expect("Only animation clips have a speed")
+            .speed = speed;
+        self
+    }
+
+    pub fn elapsed(&self) -> f32 {
+        self.animation
+            .as_ref()
+            .expect("Only animation clips have elapsed time")
+            .elapsed
+    }
+
+    pub fn seek_time(&self) -> f32 {
+        self.animation
+            .as_ref()
+            .expect("Only animation clips have a seek time")
+            .seek_time
+    }
+
+    #[doc(alias = "seek_to")]
+    pub fn set_seek_time(&mut self, new_seek_time: f32) -> &mut Self {
+        self.animation
+            .as_mut()
+            .expect("Only animation clips have a seek time")
+            .seek_time = new_seek_time;
+        self
+    }
+
+    pub fn completions(&self) -> u32 {
+        self.animation
+            .as_ref()
+            .expect("Only animation clips record the number of completions")
+            .completions
+    }
+
+    #[doc(alias = "replay")]
+    pub fn restart(&mut self) -> &mut Self {
+        let animation = self
+            .animation
+            .as_mut()
+            .expect("Only animation clips can be restarted");
+        animation.completions = 0;
+        animation.elapsed = 0.0;
+        animation.seek_time = 0.0;
+        self
+    }
+}
+
+impl Default for AnimationGraph {
+    fn default() -> Self {
+        let mut graph = StableDiGraph::new();
+        let root = graph.add_node(AnimationNode::new_blend());
+        AnimationGraph {
+            graph,
+            root: root.into(),
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 43d66fd2d81bb..d162b9953c883 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -3,6 +3,8 @@
 #![warn(missing_docs)]
 
 mod animatable;
+mod graph;
+mod transition;
 mod util;
 
 use std::ops::{Add, Deref, Mul};
@@ -19,16 +21,21 @@ use bevy_render::mesh::morph::MorphWeights;
 use bevy_time::Time;
 use bevy_transform::{prelude::Transform, TransformSystem};
 use bevy_utils::{tracing::warn, HashMap};
+use graph::evaluate_animation_graphs;
 
 #[allow(missing_docs)]
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        animatable::*, AnimationClip, AnimationPlayer, AnimationPlugin, EntityPath, Interpolation,
-        Keyframes, VariableCurve,
+        animatable::*, graph::*, transition::*, AnimationClip, AnimationPlayer, AnimationPlugin,
+        EntityPath, Interpolation, Keyframes, VariableCurve,
     };
 }
 
+pub use graph::AnimationGraph;
+use transition::update_animation_transitions;
+pub use transition::AnimationTransitions;
+
 /// List of keyframes for one of the attribute of a [`Transform`].
 #[derive(Reflect, Clone, Debug)]
 pub enum Keyframes {
@@ -217,7 +224,7 @@ pub enum RepeatAnimation {
     Forever,
 }
 
-#[derive(Debug, Reflect)]
+#[derive(Clone, Debug, Reflect)]
 struct PlayingAnimation {
     repeat: RepeatAnimation,
     speed: f32,
@@ -327,6 +334,12 @@ pub struct AnimationPlayer {
     transitions: Vec<AnimationTransition>,
 }
 
+#[derive(Bundle)]
+pub struct AnimationBundle {
+    pub graph: AnimationGraph,
+    pub transitions: AnimationTransitions,
+}
+
 impl AnimationPlayer {
     /// Start playing an animation, resetting state of the player.
     /// This will use a linear blending between the previous and the new animation to make a smooth transition.
@@ -539,16 +552,16 @@ fn entity_from_path(
 /// Verify that there are no ancestors of a given entity that have an [`AnimationPlayer`].
 fn verify_no_ancestor_player(
     player_parent: Option<&Parent>,
-    parents: &Query<(Has<AnimationPlayer>, Option<&Parent>)>,
+    parents: &Query<(Has<AnimationPlayer>, Has<AnimationGraph>, Option<&Parent>)>,
 ) -> bool {
     let Some(mut current) = player_parent.map(Parent::get) else {
         return true;
     };
     loop {
-        let Ok((has_player, parent)) = parents.get(current) else {
+        let Ok((has_player, has_graph, parent)) = parents.get(current) else {
             return true;
         };
-        if has_player {
+        if has_player || has_graph {
             return false;
         }
         if let Some(parent) = parent {
@@ -569,7 +582,7 @@ pub fn animation_player(
     names: Query<&Name>,
     transforms: Query<&mut Transform>,
     morphs: Query<&mut MorphWeights>,
-    parents: Query<(Has<AnimationPlayer>, Option<&Parent>)>,
+    parents: Query<(Has<AnimationPlayer>, Has<AnimationGraph>, Option<&Parent>)>,
     mut animation_players: Query<(Entity, Option<&Parent>, &mut AnimationPlayer)>,
 ) {
     animation_players
@@ -601,7 +614,7 @@ fn run_animation_player(
     transforms: &Query<&mut Transform>,
     morphs: &Query<&mut MorphWeights>,
     maybe_parent: Option<&Parent>,
-    parents: &Query<(Has<AnimationPlayer>, Option<&Parent>)>,
+    parents: &Query<(Has<AnimationPlayer>, Has<AnimationGraph>, Option<&Parent>)>,
     children: &Query<&Children>,
 ) {
     let paused = player.paused;
@@ -705,7 +718,7 @@ fn apply_animation(
     transforms: &Query<&mut Transform>,
     morphs: &Query<&mut MorphWeights>,
     maybe_parent: Option<&Parent>,
-    parents: &Query<(Has<AnimationPlayer>, Option<&Parent>)>,
+    parents: &Query<(Has<AnimationPlayer>, Has<AnimationGraph>, Option<&Parent>)>,
     children: &Query<&Children>,
 ) {
     let Some(animation_clip) = animations.get(&animation.animation_clip) else {
@@ -960,9 +973,21 @@ impl Plugin for AnimationPlugin {
         app.init_asset::<AnimationClip>()
             .register_asset_reflect::<AnimationClip>()
             .register_type::<AnimationPlayer>()
+            .register_type::<AnimationGraph>()
+            .register_type::<AnimationTransitions>()
+            .add_systems(
+                PostUpdate,
+                update_animation_transitions
+                    .before(animation_player)
+                    .before(evaluate_animation_graphs),
+            )
             .add_systems(
                 PostUpdate,
                 animation_player.before(TransformSystem::TransformPropagate),
+            )
+            .add_systems(
+                PostUpdate,
+                evaluate_animation_graphs.before(TransformSystem::TransformPropagate),
             );
     }
 }
diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
new file mode 100644
index 0000000000000..82e817d72c69d
--- /dev/null
+++ b/crates/bevy_animation/src/transition.rs
@@ -0,0 +1,114 @@
+//! The transition manager.
+
+use bevy_ecs::{
+    component::Component,
+    system::{Query, Res},
+};
+use bevy_math::FloatExt;
+use bevy_reflect::Reflect;
+use bevy_time::Time;
+use bevy_utils::Duration;
+
+use crate::{
+    graph::{AnimationNodeIndex, AnimationWeight},
+    AnimationGraph,
+};
+
+#[derive(Component, Default, Reflect)]
+pub struct AnimationTransitions {
+    pub transitions: Vec<AnimationTransition>,
+}
+
+#[derive(Clone, Reflect)]
+pub struct AnimationTransition {
+    node_index: AnimationNodeIndex,
+    from_weight: AnimationWeight,
+    to_weight: AnimationWeight,
+    start_time: Duration,
+    duration: Duration,
+}
+
+impl AnimationTransitions {
+    pub fn new() -> AnimationTransitions {
+        AnimationTransitions::default()
+    }
+
+    pub fn add<WFrom, WTo>(
+        &mut self,
+        node_index: AnimationNodeIndex,
+        from_weight: WFrom,
+        to_weight: WTo,
+        start_time: Duration,
+        duration: Duration,
+    ) where
+        WFrom: Into<AnimationWeight>,
+        WTo: Into<AnimationWeight>,
+    {
+        self.transitions.push(AnimationTransition {
+            node_index,
+            from_weight: from_weight.into(),
+            to_weight: to_weight.into(),
+            start_time,
+            duration,
+        })
+    }
+
+    pub fn transition<WFrom, WTo>(
+        &mut self,
+        time: &Time,
+        node_index: AnimationNodeIndex,
+        from_weight: WFrom,
+        to_weight: WTo,
+        duration: Duration,
+    ) where
+        WFrom: Into<AnimationWeight>,
+        WTo: Into<AnimationWeight>,
+    {
+        self.add(node_index, from_weight, to_weight, time.elapsed(), duration)
+    }
+
+    pub fn transition_from_current<WTo>(
+        &mut self,
+        time: &Time,
+        animation_graph: &AnimationGraph,
+        node_index: AnimationNodeIndex,
+        to_weight: WTo,
+        duration: Duration,
+    ) where
+        WTo: Into<AnimationWeight>,
+    {
+        self.transition(
+            time,
+            node_index,
+            animation_graph[node_index].weight,
+            to_weight,
+            duration,
+        )
+    }
+}
+
+impl AnimationTransition {
+    // Returns true if the transition needs to continue or false if it should be stopped.
+    fn update(&mut self, time: &Time, animation_graph: &mut AnimationGraph) -> bool {
+        let Some(mut node) = animation_graph.get_node_mut(self.node_index) else {
+            return false;
+        };
+        let t = ((time.elapsed() - self.start_time).as_secs_f32() / self.duration.as_secs_f32())
+            .clamp(0.0, 1.0);
+        node.set_weight(self.from_weight.lerp(*self.to_weight, t));
+        t < 1.0
+    }
+}
+
+pub fn update_animation_transitions(
+    time: Res<Time>,
+    mut query: Query<(&mut AnimationTransitions, &mut AnimationGraph)>,
+) {
+    for (mut animation_transitions, mut animation_graph) in query.iter_mut() {
+        animation_transitions
+            .transitions
+            .retain_mut(|animation_transition| {
+                animation_transition.update(&time, &mut animation_graph)
+            });
+    }
+}
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index c3615ff5da259..5d15b88ccaea6 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -603,12 +603,12 @@ async fn load_gltf<'a, 'b, 'c>(
         #[cfg(feature = "bevy_animation")]
         {
             // for each node root in a scene, check if it's the root of an animation
-            // if it is, add the AnimationPlayer component
+            // if it is, add the AnimationGraph component
             for node in scene.nodes() {
                 if animation_roots.contains(&node.index()) {
                     world
                         .entity_mut(*node_index_to_entity_map.get(&node.index()).unwrap())
-                        .insert(bevy_animation::AnimationPlayer::default());
+                        .insert(bevy_animation::AnimationGraph::default());
                 }
             }
         }
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index 1e1e4d4592b25..1992ae246a1a2 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -16,6 +16,7 @@ bevy = ["smallvec", "bevy_math", "smol_str"]
 glam = ["dep:glam"]
 bevy_math = ["glam", "dep:bevy_math"]
 smallvec = []
+petgraph = ["dep:petgraph"]
 # When enabled, allows documentation comments to be accessed via reflection
 documentation = ["bevy_reflect_derive/documentation"]
 
@@ -35,6 +36,7 @@ thiserror = "1.0"
 serde = "1"
 
 glam = { version = "0.25", features = ["serde"], optional = true }
+petgraph = { version = "0.6", optional = true }
 smol_str = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
diff --git a/crates/bevy_reflect/src/impls/petgraph.rs b/crates/bevy_reflect/src/impls/petgraph.rs
new file mode 100644
index 0000000000000..7a4012885276d
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/petgraph.rs
@@ -0,0 +1,9 @@
+use crate::{self as bevy_reflect};
+use bevy_reflect_derive::impl_reflect_value;
+use petgraph::stable_graph::IndexType;
+
+impl_reflect_value!(::petgraph::stable_graph::StableGraph<N: Clone, E: Clone> ());
+
+impl_reflect_value!(::petgraph::stable_graph::NodeIndex<I: Clone + IndexType> ());
+
+impl_reflect_value!(::petgraph::stable_graph::EdgeIndex<I: Clone + IndexType> ());
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index 9447cd41a6701..6cbb37654e6d3 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -487,6 +487,8 @@ mod impls {
         mod primitives3d;
         mod rect;
     }
+    #[cfg(feature = "petgraph")]
+    mod petgraph;
     #[cfg(feature = "smallvec")]
     mod smallvec;
     #[cfg(feature = "smol_str")]
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 64c07149c87a4..6142ced5c8784 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -3,7 +3,7 @@
 use std::f32::consts::PI;
 use std::time::Duration;
 
-use bevy::{animation::RepeatAnimation, pbr::CascadeShadowConfigBuilder, prelude::*};
+use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*};
 
 fn main() {
     App::new()
@@ -23,6 +23,9 @@ fn main() {
 #[derive(Resource)]
 struct Animations(Vec<Handle<AnimationClip>>);
 
+#[derive(Component)]
+struct AnimationNodes(Vec<AnimationNodeIndex>);
+
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
@@ -84,76 +87,104 @@ fn setup(
 
 // Once the scene is loaded, start the animation
 fn setup_scene_once_loaded(
+    mut commands: Commands,
     animations: Res<Animations>,
-    mut players: Query<&mut AnimationPlayer, Added<AnimationPlayer>>,
+    mut players: Query<(Entity, &mut AnimationGraph), Added<AnimationGraph>>,
 ) {
-    for mut player in &mut players {
-        player.play(animations.0[0].clone_weak()).repeat();
+    for (entity, mut player) in &mut players {
+        let root_node = player.root_node();
+        let mut animation_nodes = AnimationNodes(vec![]);
+        for (clip_index, clip) in animations.0.iter().enumerate() {
+            let node = player.add_clip_node_from(root_node, clip.clone_weak());
+            player[node]
+                .set_weight(if clip_index == 0 { 1.0 } else { 0.0 })
+                .repeat_forever()
+                .play();
+            animation_nodes.0.push(node);
+        }
+
+        commands
+            .entity(entity)
+            .insert(AnimationTransitions::new())
+            .insert(animation_nodes);
     }
 }
 
 fn keyboard_animation_control(
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut animation_players: Query<&mut AnimationPlayer>,
+    mut animation_players: Query<(
+        &mut AnimationGraph,
+        &mut AnimationTransitions,
+        &AnimationNodes,
+    )>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
+    time: Res<Time>,
 ) {
-    for mut player in &mut animation_players {
+    for (mut player, mut transitions, nodes) in &mut animation_players {
+        let node_index = nodes.0[*current_animation];
+        if keyboard_input.just_pressed(KeyCode::Enter) {
+            let next_animation = (*current_animation + 1) % animations.0.len();
+            let duration = Duration::from_millis(250);
+            transitions.transition_from_current(&time, &player, node_index, 0.0, duration);
+            transitions.transition_from_current(
+                &time,
+                &player,
+                nodes.0[next_animation],
+                1.0,
+                duration,
+            );
+
+            *current_animation = next_animation;
+        }
+
+        let node = &mut player[node_index];
+
         if keyboard_input.just_pressed(KeyCode::Space) {
-            if player.is_paused() {
-                player.resume();
+            if node.paused() {
+                node.play();
             } else {
-                player.pause();
+                node.pause();
             }
         }
 
         if keyboard_input.just_pressed(KeyCode::ArrowUp) {
-            let speed = player.speed();
-            player.set_speed(speed * 1.2);
+            let speed = node.speed();
+            node.set_speed(speed * 1.2);
         }
 
         if keyboard_input.just_pressed(KeyCode::ArrowDown) {
-            let speed = player.speed();
-            player.set_speed(speed * 0.8);
+            let speed = node.speed();
+            node.set_speed(speed * 0.8);
         }
 
         if keyboard_input.just_pressed(KeyCode::ArrowLeft) {
-            let elapsed = player.seek_time();
-            player.seek_to(elapsed - 0.1);
+            let elapsed = node.seek_time();
+            node.set_seek_time(elapsed - 0.1);
         }
 
         if keyboard_input.just_pressed(KeyCode::ArrowRight) {
-            let elapsed = player.seek_time();
-            player.seek_to(elapsed + 0.1);
-        }
-
-        if keyboard_input.just_pressed(KeyCode::Enter) {
-            *current_animation = (*current_animation + 1) % animations.0.len();
-            player
-                .play_with_transition(
-                    animations.0[*current_animation].clone_weak(),
-                    Duration::from_millis(250),
-                )
-                .repeat();
+            let elapsed = node.seek_time();
+            node.set_seek_time(elapsed + 0.1);
         }
 
         if keyboard_input.just_pressed(KeyCode::Digit1) {
-            player.set_repeat(RepeatAnimation::Count(1));
-            player.replay();
+            node.repeat_n(1);
+            node.restart();
         }
 
         if keyboard_input.just_pressed(KeyCode::Digit3) {
-            player.set_repeat(RepeatAnimation::Count(3));
-            player.replay();
+            node.repeat_n(3);
+            node.restart();
         }
 
         if keyboard_input.just_pressed(KeyCode::Digit5) {
-            player.set_repeat(RepeatAnimation::Count(5));
-            player.replay();
+            node.repeat_n(5);
+            node.restart();
         }
 
         if keyboard_input.just_pressed(KeyCode::KeyL) {
-            player.set_repeat(RepeatAnimation::Forever);
+            node.repeat_forever();
         }
     }
 }