diff --git a/Cargo.lock b/Cargo.lock
index fe0be48..63ff0b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2388,12 +2388,9 @@ dependencies = [
 
 [[package]]
 name = "field_path"
-version = "0.3.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b15fe157f96af46037f9135145fd540de8a93cf4a32e8d7ba0037796878208a"
-dependencies = [
- "hashbrown 0.16.1",
-]
+checksum = "36ccac07e4c62197b44fd7161abc6bf6b006c8dc725aeca40fd438e62d0f2ada"
 
 [[package]]
 name = "find-msvc-tools"
diff --git a/Cargo.toml b/Cargo.toml
index 0c0a181..23ab599 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,7 @@ bevy_sprite = { version = "0.18.1", default-features = false }
 bevy_pbr = { version = "0.18.1", default-features = false }
 
 # other
-field_path = "0.3"
+field_path = "0.4.1"
 nonempty = { version = "0.12", default-features = false }
 
 [workspace.lints.clippy]
diff --git a/crates/bevy_motiongfx/README.md b/crates/bevy_motiongfx/README.md
index 0fb085d..08362a6 100644
--- a/crates/bevy_motiongfx/README.md
+++ b/crates/bevy_motiongfx/README.md
@@ -40,7 +40,7 @@ use bevy_motiongfx::prelude::*;
 
 fn build_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
 ) {
     // Spawn the Entity.
     let entity = commands
@@ -48,9 +48,9 @@ fn build_timeline(
         .id();
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
     let track = b
-        .act_interp(entity, field!(<Transform>::translation::x), |x| {
+        .act_interp(entity, path!(<Transform>::translation::x), |x| {
             x + 6.0
         })
         .play(1.0)
@@ -72,7 +72,7 @@ use bevy_motiongfx::prelude::*;
 
 fn build_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut materials: ResMut<Assets<StandardMaterial>>
 ) {
     // Create the asset.
@@ -82,12 +82,12 @@ fn build_timeline(
     commands.spawn(MeshMaterial3d(material.clone()));
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
     let track = b
         .act_interp(
           // AssetIds must be type-erased.
           material.untyped().id(),
-          field!(<StandardMaterial>::base_color),
+          path!(<StandardMaterial>::base_color),
           |_| Srgba::RED.into(),
         )
         .play(1.0)
@@ -112,10 +112,10 @@ use bevy_motiongfx::prelude::*;
 
 fn build_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
 ) {
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
     // Add tracks here...
     let timeline = b.compile();
 
diff --git a/crates/bevy_motiongfx/src/controller.rs b/crates/bevy_motiongfx/src/controller.rs
index 8b09b3e..50fe4a0 100644
--- a/crates/bevy_motiongfx/src/controller.rs
+++ b/crates/bevy_motiongfx/src/controller.rs
@@ -3,7 +3,7 @@ use bevy_ecs::prelude::*;
 use bevy_time::prelude::*;
 
 use crate::MotionGfxSet;
-use crate::world::{MotionGfxWorld, TimelineId};
+use crate::manager::{MotionGfxManager, TimelineId};
 
 pub struct ControllerPlugin;
 
@@ -18,7 +18,7 @@ impl Plugin for ControllerPlugin {
 }
 
 fn realtime_player_timing(
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     q_timelines: Query<(&TimelineId, &RealtimePlayer)>,
     time: Res<Time>,
 ) {
@@ -35,7 +35,7 @@ fn realtime_player_timing(
 }
 
 fn fixed_rate_player_timing(
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut q_timelines: Query<(&TimelineId, &mut FixedRatePlayer)>,
 ) {
     for (id, mut player) in
diff --git a/crates/bevy_motiongfx/src/interpolation.rs b/crates/bevy_motiongfx/src/interpolation.rs
index 33daed3..c94cd92 100644
--- a/crates/bevy_motiongfx/src/interpolation.rs
+++ b/crates/bevy_motiongfx/src/interpolation.rs
@@ -2,34 +2,38 @@ use bevy_math::*;
 use motiongfx::prelude::*;
 use motiongfx::subject::SubjectId;
 
-pub trait ActionInterpTimelineExt {
+pub trait ActionInterpTimelineExt<W> {
     fn act_interp<I, S, T>(
         &mut self,
         target: I,
-        field: Field<S, T>,
+        field_acc: FieldAccessor<S, T>,
         action: impl Action<T>,
     ) -> InterpActionBuilder<'_, T>
     where
+        W: SubjectSource<I, S>,
         I: SubjectId,
         S: 'static,
-        T: Interpolation + ThreadSafe;
+        T: Interpolation + Clone + ThreadSafe;
 }
 
-impl ActionInterpTimelineExt for TimelineBuilder {
+impl<W: 'static> ActionInterpTimelineExt<W>
+    for TimelineBuilder<'_, W>
+{
     /// Add an [`Action`] with interpolation using
     /// [`Interpolation::interp`].
     fn act_interp<I, S, T>(
         &mut self,
         target: I,
-        field: Field<S, T>,
+        field_acc: FieldAccessor<S, T>,
         action: impl Action<T>,
     ) -> InterpActionBuilder<'_, T>
     where
+        W: SubjectSource<I, S>,
         I: SubjectId,
         S: 'static,
-        T: Interpolation + ThreadSafe,
+        T: Interpolation + Clone + ThreadSafe,
     {
-        self.act(target, field, action).with_interp(T::interp)
+        self.act(target, field_acc, action).with_interp(T::interp)
     }
 }
 
diff --git a/crates/bevy_motiongfx/src/lib.rs b/crates/bevy_motiongfx/src/lib.rs
index ae319f8..7c210a9 100644
--- a/crates/bevy_motiongfx/src/lib.rs
+++ b/crates/bevy_motiongfx/src/lib.rs
@@ -5,12 +5,11 @@ use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 
 use crate::controller::ControllerPlugin;
-use crate::world::MotionGfxWorldPlugin;
+use crate::manager::MotionGfxManagerPlugin;
 
 pub mod controller;
 pub mod interpolation;
-pub mod pipeline;
-pub mod registry;
+pub mod manager;
 pub mod world;
 
 pub mod prelude {
@@ -20,12 +19,8 @@ pub mod prelude {
     pub use crate::interpolation::{
         ActionInterpTimelineExt, Interpolation,
     };
-    pub use crate::pipeline::{
-        PipelineRegistryExt, WorldPipeline, WorldPipelineRegistry,
-    };
-    pub use crate::register_fields;
-    pub use crate::registry::FieldPathRegisterAppExt;
-    pub use crate::world::{MotionGfxWorld, TimelineId};
+    pub use crate::manager::{MotionGfxManager, TimelineId};
+    pub use crate::world::{BevyTimeline, BevyTimelineBuilder};
 }
 
 pub use motiongfx;
@@ -47,66 +42,7 @@ impl Plugin for BevyMotionGfxPlugin {
             )
                 .chain(),
         );
-        app.add_plugins((MotionGfxWorldPlugin, ControllerPlugin));
-
-        #[cfg(feature = "transform")]
-        {
-            use bevy_transform::components::Transform;
-
-            register_fields!(
-                app.register_component_field(),
-                Transform,
-                (
-                    translation(x, y, z),
-                    scale(x, y, z),
-                    rotation(x, y, z, w),
-                )
-            );
-        }
-
-        #[cfg(feature = "sprite")]
-        {
-            use bevy_sprite::prelude::*;
-
-            register_fields!(
-                app.register_component_field(),
-                Sprite,
-                (
-                    image,
-                    texture_atlas,
-                    color,
-                    flip_x,
-                    flip_y,
-                    custom_size,
-                    rect,
-                    image_mode,
-                )
-            );
-        }
-
-        #[cfg(feature = "pbr")]
-        {
-            use bevy_pbr::prelude::*;
-
-            register_fields!(
-                app.register_asset_field(),
-                StandardMaterial,
-                (
-                    base_color,
-                    emissive,
-                    perceptual_roughness,
-                    metallic,
-                    reflectance,
-                    specular_tint,
-                    diffuse_transmission,
-                    specular_transmission,
-                    thickness,
-                    ior,
-                    attenuation_distance,
-                    attenuation_color,
-                )
-            );
-        }
+        app.add_plugins((MotionGfxManagerPlugin, ControllerPlugin));
     }
 }
 
diff --git a/crates/bevy_motiongfx/src/manager.rs b/crates/bevy_motiongfx/src/manager.rs
new file mode 100644
index 0000000..aee0f02
--- /dev/null
+++ b/crates/bevy_motiongfx/src/manager.rs
@@ -0,0 +1,206 @@
+use core::ops::{Deref, DerefMut};
+
+use bevy_app::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_platform::collections::HashMap;
+use motiongfx::prelude::*;
+
+use crate::MotionGfxSet;
+use crate::controller::FixedRatePlayer;
+use crate::controller::RealtimePlayer;
+use crate::prelude::BevyTimelineBuilder;
+use crate::world::{BevyTimeline, BevyWorld};
+
+pub struct MotionGfxManagerPlugin;
+
+impl Plugin for MotionGfxManagerPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<MotionGfxManager>().add_systems(
+            PostUpdate,
+            (
+                sample_timelines.in_set(MotionGfxSet::Sample),
+                (
+                    complete_timelines::<RealtimePlayer>,
+                    complete_timelines::<FixedRatePlayer>,
+                )
+                    .after(MotionGfxSet::Sample),
+            ),
+        );
+    }
+}
+
+// TODO: Optimize samplers into parallel operations.
+// This could be deferred into motiongfx::pipeline?
+// See also https://github.com/voxell-tech/motiongfx/issues/72
+
+/// # Panics
+///
+/// Panics if the [`Timeline`] component is sampling itself.
+fn sample_timelines(world: &mut World) {
+    world.try_resource_scope::<MotionGfxManager, _>(
+        |world, mut motiongfx| {
+            motiongfx.load_pending_timelines(world);
+            motiongfx.sample_timelines(world);
+        },
+    );
+}
+
+/// A unique Id for a [`Timeline`].
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct TimelineId(u64);
+
+/// Signal for complete timelines
+#[derive(Component)]
+pub struct TimelineComplete;
+
+#[allow(clippy::type_complexity)]
+fn complete_timelines<T>(
+    mut commands: Commands,
+    motiongfx: Res<MotionGfxManager>,
+    timelines: Query<
+        (Entity, &TimelineId),
+        (With<T>, Without<TimelineComplete>),
+    >,
+) where
+    T: Component,
+{
+    for (entity, timeline) in timelines.iter() {
+        if motiongfx
+            .get_timeline(timeline)
+            .is_some_and(|t| t.is_complete())
+        {
+            commands.entity(entity).insert(TimelineComplete);
+        }
+    }
+}
+
+/// Resources that the [`motiongfx`] framework operates on.
+#[derive(Resource)]
+pub struct MotionGfxManager {
+    id: TimelineId,
+    pending_timelines: HashMap<TimelineId, MutDetect<BevyTimeline>>,
+    timelines: HashMap<TimelineId, MutDetect<BevyTimeline>>,
+    registry: Registry,
+}
+
+impl Default for MotionGfxManager {
+    fn default() -> Self {
+        Self {
+            id: TimelineId(0),
+            pending_timelines: Default::default(),
+            timelines: Default::default(),
+            registry: Default::default(),
+        }
+    }
+}
+
+impl MotionGfxManager {
+    pub fn create_builder(&mut self) -> BevyTimelineBuilder<'_> {
+        TimelineBuilder::new(&mut self.registry)
+    }
+
+    pub fn add_timeline(
+        &mut self,
+        timeline: BevyTimeline,
+    ) -> TimelineId {
+        let id = self.id;
+        self.pending_timelines.insert(id, MutDetect::new(timeline));
+
+        self.id.0 = self.id.0.wrapping_add(1);
+        id
+    }
+
+    pub fn remove_timeline(
+        &mut self,
+        id: &TimelineId,
+    ) -> Option<BevyTimeline> {
+        self.timelines
+            .remove(id)
+            .or_else(|| self.pending_timelines.remove(id))
+            .map(|t| t.take())
+    }
+
+    pub fn get_timeline(
+        &self,
+        id: &TimelineId,
+    ) -> Option<&BevyTimeline> {
+        self.timelines
+            .get(id)
+            .or_else(|| self.pending_timelines.get(id))
+            .map(|t| &**t)
+    }
+
+    pub fn get_timeline_mut(
+        &mut self,
+        id: &TimelineId,
+    ) -> Option<&mut MutDetect<BevyTimeline>> {
+        self.timelines
+            .get_mut(id)
+            .or_else(|| self.pending_timelines.get_mut(id))
+    }
+
+    pub fn load_pending_timelines(&mut self, world: &World) {
+        for (id, mut timeline) in self.pending_timelines.drain() {
+            timeline.bake_actions(
+                &self.registry,
+                BevyWorld::from_ref(world),
+            );
+            self.timelines.insert(id, timeline);
+        }
+    }
+
+    pub fn sample_timelines(&mut self, world: &mut World) {
+        for timeline in
+            self.timelines.values_mut().filter(|t| t.mutated())
+        {
+            timeline.queue_actions();
+            timeline.sample_queued_actions(
+                &self.registry,
+                BevyWorld::from_mut(world),
+            );
+            timeline.reset();
+        }
+    }
+}
+
+pub struct MutDetect<T> {
+    inner: T,
+    mutated: bool,
+}
+
+impl<T> MutDetect<T> {
+    pub fn new(inner: T) -> Self {
+        Self {
+            inner,
+            mutated: false,
+        }
+    }
+
+    pub fn mutated(&self) -> bool {
+        self.mutated
+    }
+
+    /// Reset mutation detection flag to `false`.
+    pub fn reset(&mut self) {
+        self.mutated = false
+    }
+
+    pub fn take(self) -> T {
+        self.inner
+    }
+}
+
+impl<T> Deref for MutDetect<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for MutDetect<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.mutated = true;
+        &mut self.inner
+    }
+}
diff --git a/crates/bevy_motiongfx/src/pipeline.rs b/crates/bevy_motiongfx/src/pipeline.rs
deleted file mode 100644
index 2fb1b7f..0000000
--- a/crates/bevy_motiongfx/src/pipeline.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-use bevy_ecs::component::Mutable;
-use bevy_ecs::prelude::*;
-use motiongfx::prelude::*;
-
-pub type WorldPipelineRegistry = PipelineRegistry<World>;
-pub type WorldPipeline = Pipeline<World>;
-
-pub fn bake_component_actions<S, T>(world: &World, ctx: BakeCtx)
-where
-    S: Component,
-    T: Clone + ThreadSafe,
-{
-    ctx.bake::<Entity, S, T>(|entity| world.get::<S>(entity));
-}
-
-pub fn sample_component_actions<S, T>(
-    world: &mut World,
-    ctx: SampleCtx,
-) where
-    S: Component<Mutability = Mutable>,
-    T: Clone + ThreadSafe,
-{
-    ctx.sample::<Entity, S, T>(|entity, target, accessor| {
-        if let Some(mut source) = world.get_mut::<S>(entity) {
-            *accessor.get_mut(&mut source) = target;
-        }
-    });
-}
-
-#[cfg(feature = "asset")]
-pub fn bake_asset_actions<S, T>(world: &World, ctx: BakeCtx)
-where
-    S: bevy_asset::Asset,
-    T: Clone + ThreadSafe,
-{
-    use bevy_asset::Assets;
-    use bevy_asset::UntypedAssetId;
-
-    let Some(assets) = world.get_resource::<Assets<S>>() else {
-        return;
-    };
-
-    ctx.bake::<UntypedAssetId, S, T>(|asset_id| {
-        assets.get(asset_id.typed::<S>())
-    });
-}
-
-#[cfg(feature = "asset")]
-pub fn sample_asset_actions<S, T>(world: &mut World, ctx: SampleCtx)
-where
-    S: bevy_asset::Asset,
-    T: Clone + ThreadSafe,
-{
-    use bevy_asset::Assets;
-    use bevy_asset::UntypedAssetId;
-
-    let Some(mut assets) = world.get_resource_mut::<Assets<S>>()
-    else {
-        return;
-    };
-
-    ctx.sample::<UntypedAssetId, S, T>(
-        |asset_id, target, accessor| {
-            if let Some(source) =
-                assets.get_mut(asset_id.typed::<S>())
-            {
-                *accessor.get_mut(source) = target;
-            }
-        },
-    );
-}
-
-pub trait PipelineRegistryExt {
-    fn register_component<S, T>(&mut self) -> PipelineKey
-    where
-        S: Component<Mutability = Mutable>,
-        T: Clone + ThreadSafe;
-
-    #[cfg(feature = "asset")]
-    fn register_asset<S, T>(&mut self) -> PipelineKey
-    where
-        S: bevy_asset::Asset,
-        T: Clone + ThreadSafe;
-}
-
-impl PipelineRegistryExt for WorldPipelineRegistry {
-    fn register_component<S, T>(&mut self) -> PipelineKey
-    where
-        S: Component<Mutability = Mutable>,
-        T: Clone + ThreadSafe,
-    {
-        let key = PipelineKey::new::<Entity, S, T>();
-
-        self.register_unchecked(
-            key,
-            WorldPipeline::new(
-                bake_component_actions::<S, T>,
-                sample_component_actions::<S, T>,
-            ),
-        );
-
-        key
-    }
-
-    #[cfg(feature = "asset")]
-    fn register_asset<S, T>(&mut self) -> PipelineKey
-    where
-        S: bevy_asset::Asset,
-        T: Clone + ThreadSafe,
-    {
-        use bevy_asset::UntypedAssetId;
-
-        let key = PipelineKey::new::<UntypedAssetId, S, T>();
-
-        self.register_unchecked(
-            key,
-            WorldPipeline::new(
-                bake_asset_actions::<S, T>,
-                sample_asset_actions::<S, T>,
-            ),
-        );
-
-        key
-    }
-}
diff --git a/crates/bevy_motiongfx/src/registry.rs b/crates/bevy_motiongfx/src/registry.rs
deleted file mode 100644
index 156bdbc..0000000
--- a/crates/bevy_motiongfx/src/registry.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use bevy_app::prelude::*;
-use bevy_ecs::component::Mutable;
-use bevy_ecs::prelude::*;
-use motiongfx::prelude::*;
-
-use crate::pipeline::PipelineRegistryExt;
-use crate::world::MotionGfxWorld;
-
-// TODO: Move purely the recursive logic back to motiongfx and keep
-// the registration logic here.
-
-/// Recursively register fields.
-///
-/// # Example
-///
-/// ```
-/// use bevy_ecs::entity::Entity;
-/// use bevy_app::App;
-/// use bevy_ecs::component::Component;
-/// use bevy_motiongfx::BevyMotionGfxPlugin;
-/// use bevy_motiongfx::prelude::*;
-///
-/// #[derive(Component, Default, Clone)]
-/// struct Foo {
-///     bar_x: Bar,
-///     bar_y: Bar,
-/// }
-///
-/// #[derive(Clone, Default)]
-/// struct Bar {
-///     cho_a: Cho,
-///     cho_b: Cho,
-/// }
-///
-/// #[derive(Clone, Default)]
-/// struct Cho {
-///     bo_c: Bo,
-///     bo_d: Bo,
-/// }
-///
-/// #[derive(Clone, Default)]
-/// struct Bo(f32, u32);
-///
-/// let mut app = App::new();
-/// app.add_plugins(BevyMotionGfxPlugin);
-///
-/// let a = &mut app;
-/// register_fields!(
-///     a.register_component_field(),
-///     Foo,
-///     (
-///         bar_x(cho_a(bo_c(0, 1), bo_d(0, 1))),
-///         bar_y(cho_b(bo_c(0, 1), bo_d(0, 1))),
-///     )
-/// );
-///
-/// let motiongfx = app.world().resource::<MotionGfxWorld>();
-///
-/// // Get accessor from the registry.
-/// let key = field!(<Foo>::bar_x::cho_a::bo_c::0).untyped();
-/// let accessor =
-///     motiongfx.accessor_registry.get::<Foo, f32>(&key).unwrap();
-///
-/// let mut foo = Foo::default();
-///
-/// assert_eq!(accessor.get_ref(&foo), &foo.bar_x.cho_a.bo_c.0,);
-///
-/// *accessor.get_mut(&mut foo) = 2.0;
-/// assert_eq!(accessor.get_ref(&foo), &2.0);
-///
-/// // Get pipeline from the registry.
-/// let key = PipelineKey::new::<Entity, Foo, f32>();
-/// let pipeline = motiongfx.pipeline_registry.get(&key).unwrap();
-/// ```
-#[macro_export]
-macro_rules! register_fields {
-    (
-        $app:ident.$reg_func:ident(),
-        $root:ty $(, $($rest:tt)*)?
-    ) => {
-        register_fields!(
-            $app.$reg_func::<$root>(),
-            $root $(, $($rest)*)?
-        )
-    };
-
-    (
-        $app:ident.$reg_func:ident::<$source:ty>(),
-        $root:ty $(, $($rest:tt)*)?
-    ) => {
-        $crate::registry::FieldPathRegisterAppExt
-        ::$reg_func::<$source, _>(
-            $app,
-            ::motiongfx::field_path::field!(<$root>),
-            ::motiongfx::field_path::accessor!(<$root>),
-        );
-
-        register_fields!(
-            @fields $app.$reg_func::<$source>, $root, []
-            $(, $($rest)*)?
-        );
-    };
-
-    // Recursively register all the nested fields!
-    (
-        @fields $app:ident.$reg_func:ident::<$source:ty>,
-        $root:ty, [$(::$path:tt)*],
-        (
-            $field:tt $(( $($sub_field:tt)+ ))?
-            $(,$($rest:tt)*)?
-        )
-    ) => {
-        // Register the current field.
-        // (translation(x, y, z), rotation, scale) => translation
-        $crate::registry::FieldPathRegisterAppExt
-        ::$reg_func::<$source, _>(
-            $app,
-            motiongfx::field_path::field!(<$root>$(::$path)*::$field),
-            ::motiongfx::field_path::accessor!(<$root>$(::$path)*::$field),
-        );
-
-        // Register sub fields.
-        // (translation(x, y, z), rotation, scale) => (x, y, z)
-        register_fields!(
-            @fields $app.$reg_func::<$source>,
-            $root, [$(::$path)*::$field],
-            $(( $($sub_field)+ ))?
-        );
-
-        // Register the rest of the fields.
-        // (translation(x, y, z), rotation, scale) => (rotation, scale)
-        register_fields!(
-            @fields $app.$reg_func::<$source>,
-            $root, [$(::$path)*],
-            $(( $($rest)* ))?
-        );
-    };
-
-    // There are no fields left!
-    (
-        @fields $app:ident.$reg_func:ident::<$source:ty>,
-        $root:ty, [$(::$path:tt)*]
-        $(,)? $(,())?
-    ) => {};
-}
-
-pub trait FieldPathRegisterAppExt {
-    fn register_component_field<S, T>(
-        &mut self,
-        field: Field<S, T>,
-        accessor: Accessor<S, T>,
-    ) -> &mut Self
-    where
-        S: Component<Mutability = Mutable>,
-        T: Clone + ThreadSafe;
-
-    #[cfg(feature = "asset")]
-    fn register_asset_field<S, T>(
-        &mut self,
-        field: Field<S, T>,
-        accessor: Accessor<S, T>,
-    ) -> &mut Self
-    where
-        S: bevy_asset::Asset,
-        T: Clone + ThreadSafe;
-}
-
-impl FieldPathRegisterAppExt for App {
-    fn register_component_field<S, T>(
-        &mut self,
-        field: Field<S, T>,
-        accessor: Accessor<S, T>,
-    ) -> &mut Self
-    where
-        S: Component<Mutability = Mutable>,
-        T: Clone + ThreadSafe,
-    {
-        let mut motiongfx =
-            self.world_mut().resource_mut::<MotionGfxWorld>();
-
-        motiongfx
-            .accessor_registry
-            .register(field.untyped(), accessor);
-        motiongfx.pipeline_registry.register_component::<S, T>();
-
-        self
-    }
-
-    #[cfg(feature = "asset")]
-    fn register_asset_field<S, T>(
-        &mut self,
-        field: Field<S, T>,
-        accessor: Accessor<S, T>,
-    ) -> &mut Self
-    where
-        S: bevy_asset::Asset,
-        T: Clone + ThreadSafe,
-    {
-        let mut motiongfx =
-            self.world_mut().resource_mut::<MotionGfxWorld>();
-
-        motiongfx
-            .accessor_registry
-            .register(field.untyped(), accessor);
-        motiongfx.pipeline_registry.register_asset::<S, T>();
-
-        self
-    }
-}
diff --git a/crates/bevy_motiongfx/src/world.rs b/crates/bevy_motiongfx/src/world.rs
index cbec5a7..30888f4 100644
--- a/crates/bevy_motiongfx/src/world.rs
+++ b/crates/bevy_motiongfx/src/world.rs
@@ -1,199 +1,65 @@
-use core::ops::{Deref, DerefMut};
-
-use bevy_app::prelude::*;
+use bevy_ecs::component::Mutable;
 use bevy_ecs::prelude::*;
-use bevy_platform::collections::HashMap;
-use motiongfx::prelude::{FieldAccessorRegistry, Timeline};
-
-use crate::MotionGfxSet;
-use crate::controller::FixedRatePlayer;
-use crate::pipeline::WorldPipelineRegistry;
-use crate::prelude::RealtimePlayer;
-
-pub struct MotionGfxWorldPlugin;
-
-impl Plugin for MotionGfxWorldPlugin {
-    fn build(&self, app: &mut App) {
-        app.init_resource::<MotionGfxWorld>().add_systems(
-            PostUpdate,
-            (
-                sample_timelines.in_set(MotionGfxSet::Sample),
-                (
-                    complete_timelines::<RealtimePlayer>,
-                    complete_timelines::<FixedRatePlayer>,
-                )
-                    .after(MotionGfxSet::Sample),
-            ),
-        );
-    }
-}
-
-// TODO: Optimize samplers into parallel operations.
-// This could be deferred into motiongfx::pipeline?
-// See also https://github.com/voxell-tech/motiongfx/issues/72
-
-/// # Panics
-///
-/// Panics if the [`Timeline`] component is sampling itself.
-fn sample_timelines(world: &mut World) {
-    world.try_resource_scope::<MotionGfxWorld, _>(
-        |world, mut motiongfx| {
-            motiongfx.load_pending_timelines(world);
-            motiongfx.sample_timelines(world);
-        },
-    );
-}
-
-/// A unique Id for a [`Timeline`].
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct TimelineId(u64);
+use motiongfx::prelude::*;
 
-/// Signal for complete timelines
-#[derive(Component)]
-pub struct TimelineComplete;
+/// Newtype wrapper around [`World`] that is local to this crate,
+/// allowing [`SubjectSource`] impls without violating the orphan rule.
+#[repr(transparent)]
+pub struct BevyWorld(pub World);
 
-#[allow(clippy::type_complexity)]
-fn complete_timelines<T>(
-    mut commands: Commands,
-    motiongfx: Res<MotionGfxWorld>,
-    timelines: Query<
-        (Entity, &TimelineId),
-        (With<T>, Without<TimelineComplete>),
-    >,
-) where
-    T: Component,
-{
-    for (entity, timeline) in timelines.iter() {
-        if motiongfx
-            .get_timeline(timeline)
-            .is_some_and(|t| t.is_complete())
-        {
-            commands.entity(entity).insert(TimelineComplete);
-        }
+impl BevyWorld {
+    pub fn from_ref(world: &World) -> &Self {
+        // SAFETY: `BevyWorld` is repr(transparent) over `World`.
+        unsafe { &*(world as *const World as *const Self) }
     }
-}
 
-/// Resources that the [`motiongfx`] framework operates on.
-#[derive(Resource)]
-pub struct MotionGfxWorld {
-    id: TimelineId,
-    pending_timelines: HashMap<TimelineId, MutDetect<Timeline>>,
-    timelines: HashMap<TimelineId, MutDetect<Timeline>>,
-    pub pipeline_registry: WorldPipelineRegistry,
-    pub accessor_registry: FieldAccessorRegistry,
-}
-
-impl Default for MotionGfxWorld {
-    fn default() -> Self {
-        Self {
-            id: TimelineId(0),
-            pending_timelines: Default::default(),
-            timelines: Default::default(),
-            pipeline_registry: Default::default(),
-            accessor_registry: Default::default(),
-        }
+    pub fn from_mut(world: &mut World) -> &mut Self {
+        // SAFETY: `BevyWorld` is repr(transparent) over `World`.
+        unsafe { &mut *(world as *mut World as *mut Self) }
     }
 }
 
-impl MotionGfxWorld {
-    pub fn add_timeline(&mut self, timeline: Timeline) -> TimelineId {
-        let id = self.id;
-        self.pending_timelines.insert(id, MutDetect::new(timeline));
-
-        self.id.0 = self.id.0.wrapping_add(1);
-        id
-    }
-
-    pub fn remove_timeline(
-        &mut self,
-        id: &TimelineId,
-    ) -> Option<Timeline> {
-        self.timelines
-            .remove(id)
-            .or_else(|| self.pending_timelines.remove(id))
-            .map(|t| t.take())
-    }
-
-    pub fn get_timeline(&self, id: &TimelineId) -> Option<&Timeline> {
-        self.timelines
-            .get(id)
-            .or_else(|| self.pending_timelines.get(id))
-            .map(|t| &**t)
+impl<S: Component<Mutability = Mutable>> SubjectSource<Entity, S>
+    for BevyWorld
+{
+    fn get_source(&self, id: Entity) -> Option<&S> {
+        self.0.get::<S>(id)
     }
 
-    pub fn get_timeline_mut(
+    fn apply_source<R>(
         &mut self,
-        id: &TimelineId,
-    ) -> Option<&mut MutDetect<Timeline>> {
-        self.timelines
-            .get_mut(id)
-            .or_else(|| self.pending_timelines.get_mut(id))
-    }
-
-    pub fn load_pending_timelines(&mut self, world: &mut World) {
-        for (id, mut timeline) in self.pending_timelines.drain() {
-            timeline.bake_actions(
-                &self.accessor_registry,
-                &self.pipeline_registry,
-                world,
-            );
-            self.timelines.insert(id, timeline);
-        }
-    }
-
-    pub fn sample_timelines(&mut self, world: &mut World) {
-        for timeline in
-            self.timelines.values_mut().filter(|t| t.mutated())
-        {
-            timeline.queue_actions();
-            timeline.sample_queued_actions(
-                &self.accessor_registry,
-                &self.pipeline_registry,
-                world,
-            );
-            timeline.reset();
-        }
+        id: Entity,
+        f: impl FnOnce(&mut S) -> R,
+    ) -> Option<R> {
+        self.0.get_mut::<S>(id).map(|mut m| f(m.as_mut()))
     }
 }
 
-pub struct MutDetect<T> {
-    inner: T,
-    mutated: bool,
-}
-
-impl<T> MutDetect<T> {
-    pub fn new(inner: T) -> Self {
-        Self {
-            inner,
-            mutated: false,
-        }
-    }
-
-    pub fn mutated(&self) -> bool {
-        self.mutated
-    }
-
-    /// Reset mutation detection flag to `false`.
-    pub fn reset(&mut self) {
-        self.mutated = false
-    }
-
-    pub fn take(self) -> T {
-        self.inner
+#[cfg(feature = "asset")]
+impl<S: bevy_asset::Asset>
+    SubjectSource<bevy_asset::UntypedAssetId, S> for BevyWorld
+{
+    fn get_source(
+        &self,
+        id: bevy_asset::UntypedAssetId,
+    ) -> Option<&S> {
+        self.0
+            .get_resource::<bevy_asset::Assets<S>>()?
+            .get(id.typed::<S>())
     }
-}
 
-impl<T> Deref for MutDetect<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
+    fn apply_source<R>(
+        &mut self,
+        id: bevy_asset::UntypedAssetId,
+        f: impl FnOnce(&mut S) -> R,
+    ) -> Option<R> {
+        self.0
+            .get_resource_mut::<bevy_asset::Assets<S>>()?
+            .into_inner()
+            .get_mut(id.typed::<S>())
+            .map(f)
     }
 }
 
-impl<T> DerefMut for MutDetect<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.mutated = true;
-        &mut self.inner
-    }
-}
+pub type BevyTimeline = Timeline<BevyWorld>;
+pub type BevyTimelineBuilder<'a> = TimelineBuilder<'a, BevyWorld>;
diff --git a/crates/motiongfx/README.md b/crates/motiongfx/README.md
index 63b88e5..e1a65d5 100644
--- a/crates/motiongfx/README.md
+++ b/crates/motiongfx/README.md
@@ -1,382 +1,303 @@
-# MotionGfx
-
-[![License](https://img.shields.io/badge/license-MIT%2FApache-blue.svg)](https://github.com/voxell-tech/motiongfx#license)
-[![Crates.io](https://img.shields.io/crates/v/motiongfx.svg)](https://crates.io/crates/motiongfx)
-[![Downloads](https://img.shields.io/crates/d/motiongfx.svg)](https://crates.io/crates/motiongfx)
-[![Docs](https://docs.rs/motiongfx/badge.svg)](https://docs.rs/motiongfx/latest/motiongfx/)
-[![CI](https://github.com/voxell-tech/motiongfx/workflows/CI/badge.svg)](https://github.com/voxell-tech/motiongfx/actions)
-[![Discord](https://img.shields.io/discord/442334985471655946.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/Mhnyp6VYEQ)
-
-**MotionGfx** is a backend-agnostic motion graphics framework
-built on top of [Bevy](https://bevyengine.org) ECS. It provides a
-modular foundation for procedural animations.
-
-## Key Features
-
-- **Backend agnostic**: Works with any rendering backend.
-- **Procedural**: Write animations with code - loops, functions,
-  logic.
-- **Type-erased**: Powered by
-  [Field Path](https://github.com/voxell-tech/field_path), allowing
-  runtime-flexible animation of arbitrary data.
-- **Two-way playback**: Play animations both forward and backward with
-  no extra computation.
-- **Batteries included**: Packed with common easing and interpolation
-  functions.
-
-## Core Concepts
-
-### Timeline
-
-`Timeline` is a top-level structure that coordinates a sequence of
-tracks and their associated actions. Each track acts like a
-checkpoint, allowing animations to be grouped into discrete blocks
-(especially useful for creating slides).
-
-A `Track` represents sequences of actions in chronological order, each
-with a defined start time and duration. Tracks ensure that actions
-within them are played in the correct temporal order.
-
-```rust
-use motiongfx::prelude::*;
-
-// `Timeline` can only be created via a `TimelineBuilder`.
-let mut b = TimelineBuilder::new();
-// To create a track, you first have to create the actions.
-let action = b
-    // Create an action with:
-    //   id   field path     action fn
-    .act("x", field!(<f32>), |x| x + 1.0)
-    // Every action needs an interpolation function.
-    .with_interp(|&a, &b, t| a + (b - a) * t)
-    // An optional easing function can be added.
-    .with_ease(ease::cubic::ease_in_out);
-
-// Once an action is created, it can be "played" into a
-// `TrackFragment` with a given duration.
-let frag = action.play(1.0);
-
-// Which can then be compiled into a `Track`.
-let track = frag.compile();
-
-// 1 or more tracks can be added to the builder to create a timeline.
-b.add_tracks(track);
-let timeline = b.compile();
-```
-
-#### Bake and Sample Timeline
-
-Once a timeline is created, it is ready for baking and sampling. Bake
-must happen before sample. Otherwise, sampling it will be a no-op.
-
-Registries must be created to perform baking/sampling. For more info
-about registries, see below.
-
-```rust
-use std::collections::HashMap;
-use motiongfx::prelude::*;
-
-type SubjectWorld = HashMap<&'static str, f32>;
-
-let mut world: SubjectWorld = HashMap::new();
-world.insert("x", 0.0);
-let accessor_registry = FieldAccessorRegistry::new();
-let pipeline_registry = PipelineRegistry::<SubjectWorld>::new();
-
-let mut b = TimelineBuilder::new();
-let action = b
-    .act("x", field!(<f32>), |x| x + 1.0)
-    .with_interp(|&a, &b, t| a + (b - a) * t);
-
-let track = action.play(1.0).compile();
-b.add_tracks(track);
-
-let mut timeline = b.compile();
-
-// Bake actions into segments.
-timeline.bake_actions(
-    &accessor_registry,
-    &pipeline_registry,
-    &world,
-);
-
-// Actions needs to be queued before it can be sampled.
-timeline.queue_actions();
-timeline.sample_queued_actions(
-    &accessor_registry,
-    &pipeline_registry,
-    &mut world,
-);
-```
-
-### Track Ordering
-
-`TrackFragment`s can be ordered using track ordering trait or
-functions. There are 4 ways to order track fragments:
-
-#### 1. Chain
-
-```rust
-use motiongfx::prelude::*;
-
-// Using empty fragments as an example only.
-let f0 = TrackFragment::new();
-let f1 = TrackFragment::new();
-
-let f = [f0, f1].ord_chain();
-// Or...
-// use motiongfx::track::chain;
-// let f = chain([f0, f1]);
-```
-
-Chaining runs `f1` after `f0` finishes.
-
-#### 2. All
-
-```rust
-use motiongfx::prelude::*;
-
-let f0 = TrackFragment::new();
-let f1 = TrackFragment::new();
-
-let f = [f0, f1].ord_all();
-```
-
-All runs `f0` and `f1` concurrently and waits for all of them to
-finish.
-
-#### 3. Any
-
-```rust
-use motiongfx::prelude::*;
-
-let f0 = TrackFragment::new();
-let f1 = TrackFragment::new();
-
-let f = [f0, f1].ord_any();
-```
-
-Any runs `f0` and `f1` concurrenly and wait for any of them to finish.
-
-#### 4. Flow
-
-```rust
-use motiongfx::prelude::*;
-
-let f0 = TrackFragment::new();
-let f1 = TrackFragment::new();
-
-let f = [f0, f1].ord_flow(0.5);
-```
-
-Flow runs `f1` after `f0` with a fixed delay time rather than waiting
-for `f0` to finish.
-
-### Registries
-
-Registries are used to perform reflection and safely erase types.
-
-#### Field Accessor Regisry
-
-The `FieldAccessorRegistry` maintains a mapping between animatable
-fields and their corresponding accessors, enabling MotionGfx to read
-and write values on arbitrary data structures in a type-safe yet
-dynamic way.
-
-```rust
-use motiongfx::prelude::*;
-
-#[derive(Debug, Clone, Copy)]
-struct Subject(f32);
-
-let mut accessor_registry = FieldAccessorRegistry::new();
-accessor_registry.register_typed(
-    field!(<Subject>::0),
-    accessor!(<Subject>::0)
-);
-```
-
-#### Pipeline Registry
-
-Pipelines handle the baking of actions and the sampling of animation
-segments for playback or preview.
-
-```rust
-use std::collections::HashMap;
-
-use motiongfx::prelude::*;
-
-#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
-struct Id(u32);
-#[derive(Debug, Clone, Copy)]
-struct Subject(f32);
-type SubjectWorld = HashMap<Id, Subject>;
-
-let mut pipeline_registry = PipelineRegistry::<SubjectWorld>::new();
-pipeline_registry.register_unchecked(
-    PipelineKey::new::<Id, Subject, f32>(),
-    Pipeline::new(
-        |world, ctx| {
-            ctx.bake::<Id, Subject, f32>(|id| world.get(&id));
-        },
-        |world, ctx| {
-            ctx.sample::<Id, Subject, f32>(
-                |id, target, accessor| {
-                    if let Some(x) = world.get_mut(&id) {
-                        *accessor.get_mut(x) = target;
-                    }
-                },
-            );
-        },
-    ),
-);
-```
-
-### Subject World
-
-Because MotionGfx is backend agnostic, it can be used to animate
-subjects in any world. A typical subject world would hold unique Ids
-that maps subject entities to their associated animatable components.
-
-A simple example of such would be a `HashMap`.
-
-```rust
-use std::collections::HashMap;
-
-#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
-struct Id(u32);
-#[derive(Debug, Clone, Copy)]
-struct Subject(f32);
-type SubjectWorld = HashMap<Id, Subject>;
-```
-
-Below is a comprehensive example on how MotionGfx can be used with a
-custom world!
-
-```rust
-use std::collections::HashMap;
-
-use motiongfx::prelude::*;
-
-// First, we have to initialize a subject world and the
-// registries.
-#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
-struct Id(u32);
-#[derive(Debug, Clone, Copy)]
-struct Subject(f32);
-type SubjectWorld = HashMap<Id, Subject>;
-
-let mut subject_world = SubjectWorld::new();
-let mut accessor_registry = FieldAccessorRegistry::new();
-let mut pipeline_registry =
-    PipelineRegistry::<SubjectWorld>::new();
-
-// The accessor registry should contain accessors to the fields in
-// the subjects. In our case, it's just the first field in
-// the tuple struct: `Subject::0`.
-
-accessor_registry.register_typed(
-    field!(<Subject>::0),
-    accessor!(<Subject>::0),
-);
-
-// Similarly, the pipeline registry shoiud contain pipelines to
-// bake and sample the fields in the subjects.
-
-pipeline_registry.register_unchecked(
-    PipelineKey::new::<Id, Subject, f32>(),
-    Pipeline::new(
-        |world, ctx| {
-            ctx.bake::<Id, Subject, f32>(|id| world.get(&id));
-        },
-        |world, ctx| {
-            ctx.sample::<Id, Subject, f32>(
-                |id, target, accessor| {
-                    if let Some(x) = world.get_mut(&id) {
-                        *accessor.get_mut(x) = target;
-                    }
-                },
-            );
-        },
-    ),
-);
-
-// Now that the registries are complete, we can start adding
-// subjects into the subject world.
-
-subject_world.insert(Id(1), Subject(0.0));
-
-// A timeline can only be created via the `TimelineBuilder`.
-
-let mut builder = TimelineBuilder::new();
-
-let track = builder
-    // Creates the action.
-    .act(Id(1), field!(<Subject>::0), |x| x + 10.0)
-    // Adds an interpolation method.
-    .with_interp(|&a, &b, t| a + (b - a) * t)
-    // Specifies the duration of the action.
-    .play(1.0)
-    // Compiles into a track.
-    .compile();
-
-// Adds the track to the builder.
-builder.add_tracks(track);
-// And compile it into a timeline.
-let mut timeline = builder.compile();
-// The timeline needs to be baked once before sampling can happen.
-timeline.bake_actions(
-    &accessor_registry,
-    &pipeline_registry,
-    &subject_world,
-);
-
-// Let's visualize the current state of the subject world before
-// the sampling happens.
-println!("Before: {:?}", subject_world);
-
-// We fast forward the timeline.
-timeline.set_target_time(0.5);
-// Actions need to be queued before it can be sampled.
-// The queued actions are stored internally.
-timeline.queue_actions();
-timeline.sample_queued_actions(
-    &accessor_registry,
-    &pipeline_registry,
-    &mut subject_world,
-);
-
-// Visualize the state of the subject world after the sampling.
-println!("After:  {:?}", subject_world);
-```
-
-## Officially Supported Backends
-
-- [Bevy MotionGfx](https://crates.io/crates/bevy_motiongfx)
-
-## Join the community!
-
-You can join us on the [Voxell discord server](https://discord.gg/Mhnyp6VYEQ).
-
-## Inspirations and Similar Projects
-
-- [Motion Canvas](https://motioncanvas.io/)
-- [Manim](https://www.manim.community/)
-
-## Version Matrix
-
-| Bevy    | MotionGfx  |
-| ------- | ---------- |
-| 0.18    | 0.2        |
-| 0.17    | 0.1        |
-
-## License
-
-`motiongfx` is dual-licensed under either:
-
-- MIT License ([LICENSE-MIT](/LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
-- Apache License, Version 2.0 ([LICENSE-APACHE](/LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
-
-This means you can select the license you prefer!
-This dual-licensing approach is the de-facto standard in the Rust ecosystem and there are [very good reasons](https://github.com/bevyengine/bevy/issues/2373) to include both.
-
+# MotionGfx
+
+[![License](https://img.shields.io/badge/license-MIT%2FApache-blue.svg)](https://github.com/voxell-tech/motiongfx#license)
+[![Crates.io](https://img.shields.io/crates/v/motiongfx.svg)](https://crates.io/crates/motiongfx)
+[![Downloads](https://img.shields.io/crates/d/motiongfx.svg)](https://crates.io/crates/motiongfx)
+[![Docs](https://docs.rs/motiongfx/badge.svg)](https://docs.rs/motiongfx/latest/motiongfx/)
+[![CI](https://github.com/voxell-tech/motiongfx/workflows/CI/badge.svg)](https://github.com/voxell-tech/motiongfx/actions)
+[![Discord](https://img.shields.io/discord/442334985471655946.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/Mhnyp6VYEQ)
+
+**MotionGfx** is a backend-agnostic motion graphics framework
+built on top of [Bevy](https://bevyengine.org) ECS. It provides a
+modular foundation for procedural animations.
+
+## Key Features
+
+- **Backend agnostic**: Works with any rendering backend.
+- **Procedural**: Write animations with code - loops, functions,
+  logic.
+- **Type-erased**: Powered by
+  [Field Path](https://github.com/voxell-tech/field_path), allowing
+  runtime-flexible animation of arbitrary data.
+- **Two-way playback**: Play animations both forward and backward with
+  no extra computation.
+- **Batteries included**: Packed with common easing and interpolation
+  functions.
+
+## Quick Start
+
+```rust
+use motiongfx::prelude::*;
+
+// A world is where you hold all your animatable subjects.
+struct World(Vec<f32>);
+
+// Teach `motiongfx` how to read and write `f32` subjects from `World`.
+impl SubjectSource<usize, f32> for World {
+    fn get_source(&self, id: usize) -> Option<&f32> {
+        self.0.get(id)
+    }
+
+    fn apply_source<R>(
+        &mut self,
+        id: usize,
+        f: impl FnOnce(&mut f32) -> R,
+    ) -> Option<R> {
+        self.0.get_mut(id).map(f)
+    }
+}
+
+let mut world = World(vec![0.0]);
+
+// The registry tracks which types are animated.
+let mut registry = Registry::new();
+// The builder is typed on the world.
+let mut b = registry.create_builder::<World>();
+
+let id = 0;
+// Create an action with: id, field path, action fn.
+let action = b
+    // Animate subject 0 from its current value to +10.0.
+    .act(id, path!(<f32>), |x| x + 10.0)
+    // Every action needs an interpolation function.
+    .with_interp(|a, b, t| a + (b - a) * t);
+
+// "Play" the action into a `TrackFragment` with a duration.
+let frag = action.play(1.0);
+
+// Compile into a `Track`
+// See "Track Ordering" section for composing fragments.
+let track = frag.compile();
+
+b.add_tracks(track);
+let mut timeline = b.compile();
+
+// Bake must run once before sampling.
+timeline.bake_actions(&registry, &world);
+
+// Sample at t = 0.5, world.0[0] should now be 5.0.
+timeline.set_target_time(0.5);
+timeline.queue_actions();
+timeline.sample_queued_actions(&registry, &mut world);
+
+assert!((world.0[0] - 5.0).abs() < f32::EPSILON);
+```
+
+## Creating your first animation
+
+### The World
+
+Think of a **world** as a container for everything you want to
+animate. Each item inside it (called a **subject**) has an ID so
+`motiongfx` can find it. To connect your world to `motiongfx`,
+implement `SubjectSource` with two methods: one to read a subject by
+ID, and one to write to it.
+
+Because of Rust's orphan rule, `SubjectSource` must be implemented on
+a type local to your crate. If you cannot own the type directly, wrap
+it in a newtype.
+
+```rust
+# use motiongfx::prelude::*;
+// Own your world so you can impl SubjectSource on it.
+// Each f32 value is a subject, accessed by its index.
+struct World(Vec<f32>);
+
+impl SubjectSource<usize, f32> for World {
+    fn get_source(&self, id: usize) -> Option<&f32> {
+        self.0.get(id)
+    }
+
+    fn apply_source<R>(
+        &mut self,
+        id: usize,
+        f: impl FnOnce(&mut f32) -> R,
+    ) -> Option<R> {
+        self.0.get_mut(id).map(f)
+    }
+}
+```
+
+
+### The Registry
+
+The `Registry` keeps track of how to animate your types behind the
+scenes. `motiongfx` is type-erased at runtime, so it needs the
+registry to know how to read and write each field. You don't need to
+set it up manually, just create one and pass it to the builder.
+Registration happens automatically the first time you add an
+animation.
+
+```rust
+# use motiongfx::prelude::*;
+let mut registry = Registry::new();
+```
+
+### The Timeline Builder
+
+The `TimelineBuilder` is where you describe your animations. Create
+one from the registry, typed to your data holder:
+
+```rust
+# use motiongfx::prelude::*;
+# let mut registry = Registry::new();
+# type World = Vec<f32>;
+let mut b = registry.create_builder::<World>();
+```
+
+### Building the Timeline
+
+Animations are built up in layers:
+
+1. An **action** says what to animate and how to transform it.
+2. A **track fragment** gives the action a duration by calling `.play(seconds)`.
+3. A **track** is one or more fragments compiled together. You can
+   order fragments before compiling (see [Track Ordering](#track-ordering)).
+4. A **timeline** combines all your tracks into one playable sequence.
+
+```rust
+# #[path = "docs/world.rs"] mod _doc; use _doc::*;
+# let mut registry = Registry::new();
+# let mut b = registry.create_builder::<World>();
+# let mut world = World(vec![0.0]);
+let id = 0;
+// Act: animate subject 0 from its current value to +10.0.
+let action = b
+    .act(id, path!(<f32>), |x| x + 10.0)
+    // Every action needs an interpolation function.
+    .with_interp(|a: &f32, b: &f32, t| a + (b - a) * t)
+    // An optional easing function can be added.
+    .with_ease(ease::cubic::ease_in_out);
+
+// Play: turn the action into a fragment with a 1-second duration.
+let frag = action.play(1.0);
+
+// Compile the fragment into a Track.
+let track = frag.compile();
+
+// Add the track and compile into a Timeline.
+b.add_tracks(track);
+let timeline = b.compile();
+```
+
+### Bake and Sample
+
+Before playing an animation, you need to **bake** it. Baking reads
+the starting values from your world and prepares the animation data.
+This only needs to happen once, right after building the timeline.
+
+To advance the animation, set a target time, then **queue** and
+**sample**. Queuing figures out which actions are active at that
+time, and sampling writes the new values back into your world.
+
+A timeline can also have multiple tracks, each acting as a chapter.
+Use `set_target_track` to jump between them.
+
+```rust
+# #[path = "docs/world.rs"] mod _doc; use _doc::*;
+# let mut subjects = World(vec![0.0]);
+# let (registry, mut timeline) = timeline();
+// Bake once after building the timeline.
+timeline.bake_actions(&registry, &subjects);
+
+// Set target time, queue, then sample.
+timeline.set_target_time(0.5);
+timeline.queue_actions();
+timeline.sample_queued_actions(&registry, &mut subjects);
+
+assert!((subjects.0[0] - 5.0).abs() < f32::EPSILON);
+```
+
+### Track Ordering
+
+You can control how fragments play relative to each other. There are
+4 ordering combinators:
+
+#### 1. Chain
+
+```rust
+use motiongfx::prelude::*;
+
+// Using empty fragments as an example only.
+let f0 = TrackFragment::new();
+let f1 = TrackFragment::new();
+
+let f = [f0, f1].ord_chain();
+// Or...
+// use motiongfx::track::chain;
+// let f = chain([f0, f1]);
+```
+
+`f1` plays after `f0` finishes.
+
+#### 2. All
+
+```rust
+use motiongfx::prelude::*;
+
+let f0 = TrackFragment::new();
+let f1 = TrackFragment::new();
+
+let f = [f0, f1].ord_all();
+```
+
+`f0` and `f1` play at the same time, and the result finishes when
+both are done.
+
+#### 3. Any
+
+```rust
+use motiongfx::prelude::*;
+
+let f0 = TrackFragment::new();
+let f1 = TrackFragment::new();
+
+let f = [f0, f1].ord_any();
+```
+
+`f0` and `f1` play at the same time, and the result finishes when
+either one is done.
+
+#### 4. Flow
+
+```rust
+use motiongfx::prelude::*;
+
+let f0 = TrackFragment::new();
+let f1 = TrackFragment::new();
+
+let f = [f0, f1].ord_flow(0.5);
+```
+
+`f1` starts 0.5 seconds after `f0` begins, regardless of how long
+`f0` takes.
+
+## Officially Supported Backends
+
+- [Bevy MotionGfx](https://crates.io/crates/bevy_motiongfx)
+
+## Join the community!
+
+You can join us on the [Voxell discord server](https://discord.gg/Mhnyp6VYEQ).
+
+## Inspirations and Similar Projects
+
+- [Motion Canvas](https://motioncanvas.io/)
+- [Manim](https://www.manim.community/)
+
+## Version Matrix
+
+| Bevy    | MotionGfx  |
+| ------- | ---------- |
+| 0.18    | 0.2        |
+| 0.17    | 0.1        |
+
+## License
+
+`motiongfx` is dual-licensed under either:
+
+- MIT License ([LICENSE-MIT](/LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
+- Apache License, Version 2.0 ([LICENSE-APACHE](/LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+
+This means you can select the license you prefer!
+This dual-licensing approach is the de-facto standard in the Rust ecosystem and there are [very good reasons](https://github.com/bevyengine/bevy/issues/2373) to include both.
diff --git a/crates/motiongfx/docs/world.rs b/crates/motiongfx/docs/world.rs
new file mode 100644
index 0000000..09558a5
--- /dev/null
+++ b/crates/motiongfx/docs/world.rs
@@ -0,0 +1,30 @@
+pub use motiongfx::prelude::*;
+
+pub struct World(pub Vec<f32>);
+
+impl SubjectSource<usize, f32> for World {
+    fn get_source(&self, id: usize) -> Option<&f32> {
+        self.0.get(id)
+    }
+
+    fn apply_source<R>(
+        &mut self,
+        id: usize,
+        f: impl FnOnce(&mut f32) -> R,
+    ) -> Option<R> {
+        self.0.get_mut(id).map(f)
+    }
+}
+
+pub fn timeline() -> (Registry, Timeline<World>) {
+    let mut registry = Registry::new();
+    let mut b = registry.create_builder::<World>();
+    let track = b
+        .act(0usize, path!(<f32>), |x| x + 10.0)
+        .with_interp(|a: &f32, b: &f32, t| a + (b - a) * t)
+        .play(1.0)
+        .compile();
+    b.add_tracks(track);
+    let timeline = b.compile();
+    (registry, timeline)
+}
diff --git a/crates/motiongfx/examples/custom_world.rs b/crates/motiongfx/examples/custom_world.rs
index 7ed2c01..0ccf907 100644
--- a/crates/motiongfx/examples/custom_world.rs
+++ b/crates/motiongfx/examples/custom_world.rs
@@ -3,16 +3,14 @@ use std::collections::HashMap;
 use motiongfx::prelude::*;
 
 struct World {
-    accessor_registry: FieldAccessorRegistry,
-    pipeline_registry: PipelineRegistry<SubjectWorld>,
+    registry: Registry,
     subject_world: SubjectWorld,
 }
 
 impl World {
     pub fn new() -> Self {
         Self {
-            accessor_registry: FieldAccessorRegistry::new(),
-            pipeline_registry: PipelineRegistry::new(),
+            registry: Registry::new(),
             subject_world: SubjectWorld {
                 world: HashMap::new(),
             },
@@ -53,11 +51,6 @@ struct Line {
 fn main() {
     let mut world = World::new();
 
-    // Register the accessors.
-    register_accessors(&mut world.accessor_registry);
-    // Regsitre the pipelines.
-    register_pipelines(&mut world.pipeline_registry);
-
     // Spawn in some subjects.
     world
         .subject_world
@@ -68,21 +61,21 @@ fn main() {
         .world
         .insert(Id(1), Subject::Line(Line::default()));
 
-    let mut builder = TimelineBuilder::new();
+    let mut builder = world.registry.create_builder();
 
     // Create the track.
     let track = [
         builder
-            .act(Id(0), field!(<Point>::x), |x| x + 72.0)
+            .act(Id(0), path!(<Point>::x), |x| x + 72.0)
             .with_interp(linear_f32)
             .play(1.0),
         [
             builder
-                .act(Id(1), field!(<Line>::p0::y), |y| y + 42.0)
+                .act(Id(1), path!(<Line>::p0::y), |y| y + 42.0)
                 .with_interp(linear_f32)
                 .play(2.0),
             builder
-                .act(Id(1), field!(<Line>::p1), |_| Point {
+                .act(Id(1), path!(<Line>::p1), |_| Point {
                     x: 6.0,
                     y: 6.0,
                 })
@@ -98,11 +91,7 @@ fn main() {
     let mut timeline = builder.compile();
 
     // Bake actions into segments.
-    timeline.bake_actions(
-        &world.accessor_registry,
-        &world.pipeline_registry,
-        &world.subject_world,
-    );
+    timeline.bake_actions(&world.registry, &world.subject_world);
 
     // Change the target time.
     timeline.set_target_time(1.5);
@@ -113,8 +102,7 @@ fn main() {
     // Queue and sample the actions.
     timeline.queue_actions();
     timeline.sample_queued_actions(
-        &world.accessor_registry,
-        &world.pipeline_registry,
+        &world.registry,
         &mut world.subject_world,
     );
 
@@ -138,8 +126,7 @@ fn main() {
     // Queue and sample the actions.
     timeline.queue_actions();
     timeline.sample_queued_actions(
-        &world.accessor_registry,
-        &world.pipeline_registry,
+        &world.registry,
         &mut world.subject_world,
     );
 
@@ -150,130 +137,44 @@ fn main() {
     );
 }
 
-fn register_pipelines(
-    pipeline_registry: &mut PipelineRegistry<SubjectWorld>,
-) {
-    pipeline_registry.register_unchecked(
-        PipelineKey::new::<Id, Point, f32>(),
-        Pipeline::new(
-            |world, ctx| {
-                ctx.bake::<Id, Point, f32>(|id| {
-                    let subject = world.world.get(&id)?;
-                    match subject {
-                        Subject::Point(point) => Some(point),
-                        Subject::Line(_) => None,
-                    }
-                });
-            },
-            |world, ctx| {
-                ctx.sample::<Id, Point, f32>(
-                    |id, target, accessor| {
-                        let Some(subject) = world.world.get_mut(&id)
-                        else {
-                            return;
-                        };
-
-                        if let Subject::Point(point) = subject {
-                            *accessor.get_mut(point) = target;
-                        }
-                    },
-                );
-            },
-        ),
-    );
-
-    pipeline_registry.register_unchecked(
-        PipelineKey::new::<Id, Line, Point>(),
-        Pipeline::new(
-            |world, ctx| {
-                ctx.bake::<Id, Line, Point>(|id| {
-                    let subject = world.world.get(&id)?;
-                    match subject {
-                        Subject::Line(line) => Some(line),
-                        Subject::Point(_) => None,
-                    }
-                });
-            },
-            |world, ctx| {
-                ctx.sample::<Id, Line, Point>(
-                    |id, target, accessor| {
-                        let Some(subject) = world.world.get_mut(&id)
-                        else {
-                            return;
-                        };
-
-                        if let Subject::Line(line) = subject {
-                            *accessor.get_mut(line) = target;
-                        }
-                    },
-                );
-            },
-        ),
-    );
-
-    // TODO: This looks almost exactly the same as above, could
-    // pipeline be simplified enough to ignore the target field?
-    pipeline_registry.register_unchecked(
-        PipelineKey::new::<Id, Line, f32>(),
-        Pipeline::new(
-            |world, ctx| {
-                ctx.bake::<Id, Line, f32>(|id| {
-                    let subject = world.world.get(&id)?;
-                    match subject {
-                        Subject::Line(line) => Some(line),
-                        Subject::Point(_) => None,
-                    }
-                });
-            },
-            |world, ctx| {
-                ctx.sample::<Id, Line, f32>(
-                    |id, target, accessor| {
-                        let Some(subject) = world.world.get_mut(&id)
-                        else {
-                            return;
-                        };
+impl SubjectSource<Id, Point> for SubjectWorld {
+    fn get_source(&self, id: Id) -> Option<&Point> {
+        match self.world.get(&id)? {
+            Subject::Point(point) => Some(point),
+            Subject::Line(_) => None,
+        }
+    }
 
-                        if let Subject::Line(line) = subject {
-                            *accessor.get_mut(line) = target;
-                        }
-                    },
-                );
-            },
-        ),
-    );
+    fn apply_source<R>(
+        &mut self,
+        id: Id,
+        f: impl FnOnce(&mut Point) -> R,
+    ) -> Option<R> {
+        match self.world.get_mut(&id)? {
+            Subject::Point(point) => Some(f(point)),
+            Subject::Line(_) => None,
+        }
+    }
 }
 
-fn register_accessors(accessor_registry: &mut FieldAccessorRegistry) {
-    // In real use cases, a macro should be used!
-    // Refer to `bevy_motiongfx` for now...
+impl SubjectSource<Id, Line> for SubjectWorld {
+    fn get_source(&self, id: Id) -> Option<&Line> {
+        match self.world.get(&id)? {
+            Subject::Line(line) => Some(line),
+            Subject::Point(_) => None,
+        }
+    }
 
-    // Point -> f32.
-    accessor_registry
-        .register_typed(field!(<Point>::x), accessor!(<Point>::x));
-    accessor_registry
-        .register_typed(field!(<Point>::y), accessor!(<Point>::y));
-    // Line -> Point.
-    accessor_registry
-        .register_typed(field!(<Line>::p0), accessor!(<Line>::p0));
-    accessor_registry
-        .register_typed(field!(<Line>::p1), accessor!(<Line>::p1));
-    // Line -> Point -> f32.
-    accessor_registry.register_typed(
-        field!(<Line>::p0::x),
-        accessor!(<Line>::p0::x),
-    );
-    accessor_registry.register_typed(
-        field!(<Line>::p0::y),
-        accessor!(<Line>::p0::y),
-    );
-    accessor_registry.register_typed(
-        field!(<Line>::p1::x),
-        accessor!(<Line>::p1::x),
-    );
-    accessor_registry.register_typed(
-        field!(<Line>::p1::y),
-        accessor!(<Line>::p1::y),
-    );
+    fn apply_source<R>(
+        &mut self,
+        id: Id,
+        f: impl FnOnce(&mut Line) -> R,
+    ) -> Option<R> {
+        match self.world.get_mut(&id)? {
+            Subject::Line(line) => Some(f(line)),
+            Subject::Point(_) => None,
+        }
+    }
 }
 
 fn linear_f32(a: &f32, b: &f32, t: f32) -> f32 {
diff --git a/crates/motiongfx/src/action.rs b/crates/motiongfx/src/action.rs
index 8bb06fc..c596ac4 100644
--- a/crates/motiongfx/src/action.rs
+++ b/crates/motiongfx/src/action.rs
@@ -118,29 +118,28 @@ pub struct UntypedSubjectId {
 }
 
 impl UntypedSubjectId {
-    pub fn new<I: SubjectId>(uid: UId) -> Self {
+    pub const PLACEHOLDER: Self =
+        Self::placeholder_with_u64(u64::MAX);
+
+    pub const fn new<I: SubjectId>(uid: UId) -> Self {
         Self {
             type_id: TypeId::of::<I>(),
             uid,
         }
     }
 
-    pub fn placeholder() -> Self {
-        Self::placeholder_with_u64(0)
-    }
-
-    pub fn placeholder_with_u64(id: u64) -> Self {
+    pub const fn placeholder_with_u64(id: u64) -> Self {
         Self {
             type_id: TypeId::of::<()>(),
             uid: UId(id),
         }
     }
 
-    pub fn type_id(&self) -> TypeId {
+    pub const fn type_id(&self) -> TypeId {
         self.type_id
     }
 
-    pub fn uid(&self) -> UId {
+    pub const fn uid(&self) -> UId {
         self.uid
     }
 }
@@ -252,10 +251,8 @@ impl ActionWorld {
             .get_resource_or_insert_with(|| IdRegistry::new())
             .register_instance(target);
 
-        let key = ActionKey {
-            subject_id: UntypedSubjectId::new::<I>(uid),
-            field,
-        };
+        let key =
+            ActionKey::new(UntypedSubjectId::new::<I>(uid), field);
         let world = self.world.spawn((
             key,
             IdType::<I>::new(),
diff --git a/crates/motiongfx/src/lib.rs b/crates/motiongfx/src/lib.rs
index 7a8c281..f98d59d 100644
--- a/crates/motiongfx/src/lib.rs
+++ b/crates/motiongfx/src/lib.rs
@@ -6,20 +6,18 @@ extern crate alloc;
 pub mod action;
 pub mod ease;
 pub mod pipeline;
+pub mod registry;
 pub mod sequence;
 pub mod subject;
 pub mod timeline;
 pub mod track;
+pub mod world;
 
 // Re-exports field_path as it is essential for motiongfx to work!
 pub use field_path;
 
 pub mod prelude {
-    pub use field_path::accessor;
-    pub use field_path::accessor::{Accessor, UntypedAccessor};
-    pub use field_path::field;
-    pub use field_path::field::{Field, UntypedField};
-    pub use field_path::registry::FieldAccessorRegistry;
+    pub use field_path::field_accessor::FieldAccessor;
 
     pub use crate::ThreadSafe;
     pub use crate::action::{
@@ -27,11 +25,34 @@ pub mod prelude {
         InterpFn,
     };
     pub use crate::ease;
-    pub use crate::pipeline::{
-        BakeCtx, Pipeline, PipelineKey, PipelineRegistry, SampleCtx,
+    pub use crate::path;
+    pub use crate::pipeline::PipelineKey;
+    pub use crate::registry::{
+        AccessorRegistry, PipelineRegistry, Registry,
     };
     pub use crate::timeline::{Timeline, TimelineBuilder};
     pub use crate::track::{Track, TrackFragment, TrackOrdering};
+    pub use crate::world::SubjectSource;
+}
+
+/// See [`field_path::field_accessor!`].
+///
+/// This macro just forwards the tokens to the mentioned macro.
+///
+/// ## Example
+///
+/// ```
+/// use motiongfx::path;
+///
+/// struct Foo(u32);
+///
+/// let path = path!(<Foo>::0);
+/// ```
+#[macro_export]
+macro_rules! path {
+    ($($t:tt)*) => {
+        $crate::field_path::field_accessor!($($t)*)
+    };
 }
 
 /// Auto trait for types that implements [`Send`] + [`Sync`] +
diff --git a/crates/motiongfx/src/pipeline.rs b/crates/motiongfx/src/pipeline.rs
index be7a352..bc3eb1c 100644
--- a/crates/motiongfx/src/pipeline.rs
+++ b/crates/motiongfx/src/pipeline.rs
@@ -1,229 +1,278 @@
+pub mod func_pointers;
+
 use core::any::TypeId;
+use core::marker::PhantomData;
 
-use bevy_ecs::prelude::*;
-use bevy_platform::collections::HashMap;
-use field_path::accessor::Accessor;
-use field_path::registry::FieldAccessorRegistry;
+use func_pointers::{BakeFnPtr, SampleFnPtr};
 
 use crate::ThreadSafe;
 use crate::action::{
     ActionClip, ActionKey, ActionWorld, EaseStorage, InterpStorage,
     SampleMode, Segment,
 };
+use crate::pipeline::func_pointers::{BakeFn, SampleFn};
+use crate::registry::AccessorRegistry;
 use crate::subject::SubjectId;
 use crate::track::Track;
+use crate::world::SubjectSource;
+
+pub struct PipelineHandle<W, I, S, T> {
+    #[expect(clippy::complexity)]
+    _marker: PhantomData<fn() -> (W, I, S, T)>,
+}
+
+impl<W, I, S, T> PipelineHandle<W, I, S, T>
+where
+    W: 'static,
+    I: SubjectId,
+    S: 'static,
+    T: 'static,
+{
+    pub fn new() -> Self {
+        Self {
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn as_key(&self) -> PipelineKey {
+        PipelineKey::new::<W, I, S, T>()
+    }
+}
 
-/// Uniquely identifies a [`Pipeline`] to bake and sample a target
-/// field from a subject's source data structure.
+impl<W, I, S, T> Copy for PipelineHandle<W, I, S, T> {}
+
+impl<W, I, S, T> Clone for PipelineHandle<W, I, S, T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<W, I, S, T> Default for PipelineHandle<W, I, S, T>
+where
+    W: 'static,
+    I: SubjectId,
+    S: 'static,
+    T: 'static,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Uniquely identifies a [`Pipeline`] by its world, subject, source,
+/// and target types.
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord,
 )]
 pub struct PipelineKey {
-    /// The [`TypeId`] of the [`SubjectId`].
+    world_id: TypeId,
     subject_id: TypeId,
-    /// The [`TypeId`] of the source type.
     source_id: TypeId,
-    /// The [`TypeId`] of the target type.
     target_id: TypeId,
 }
 
 impl PipelineKey {
-    pub fn new<I, S, T>() -> Self
+    pub fn new<W, I, S, T>() -> Self
     where
+        W: 'static,
         I: SubjectId,
         S: 'static,
         T: 'static,
     {
         Self {
+            world_id: TypeId::of::<W>(),
             subject_id: TypeId::of::<I>(),
             source_id: TypeId::of::<S>(),
             target_id: TypeId::of::<T>(),
         }
     }
 
-    pub fn from_action_key(key: ActionKey) -> Self {
+    pub fn from_action_key<W: 'static>(key: ActionKey) -> Self {
         Self {
+            world_id: TypeId::of::<W>(),
             subject_id: key.subject_id().type_id(),
             source_id: key.field().source_id(),
             target_id: key.field().target_id(),
         }
     }
-}
 
-pub type BakeFn<W> = fn(&W, BakeCtx);
-pub type SampleFn<W> = fn(&mut W, SampleCtx);
+    pub(crate) fn world_id(&self) -> TypeId {
+        self.world_id
+    }
+}
 
+/// A pipeline for baking and sampling actions of type `(I, S, T)`.
+/// The world type `W` is erased at storage; it must match at call sites.
 #[derive(Debug, Clone, Copy)]
-pub struct Pipeline<W> {
+pub struct Pipeline<W, I, S, T> {
     bake: BakeFn<W>,
     sample: SampleFn<W>,
+    #[expect(clippy::complexity)]
+    _marker: PhantomData<fn() -> (I, S, T)>,
 }
 
-impl<W> Pipeline<W> {
-    pub fn new(bake: BakeFn<W>, sample: SampleFn<W>) -> Self {
-        Self { bake, sample }
+impl<W, I, S, T> Pipeline<W, I, S, T> {
+    pub fn new() -> Self
+    where
+        W: SubjectSource<I, S>,
+        I: SubjectId,
+        S: 'static,
+        T: Clone + ThreadSafe,
+    {
+        Self {
+            bake: bake::<W, I, S, T>,
+            sample: sample::<W, I, S, T>,
+            _marker: PhantomData,
+        }
     }
 
-    pub fn bake(&self, world: &W, ctx: BakeCtx) {
-        (self.bake)(world, ctx)
+    pub fn untyped(&self) -> PipelineUntyped {
+        PipelineUntyped {
+            bake: BakeFnPtr::new(self.bake),
+            sample: SampleFnPtr::new(self.sample),
+        }
     }
+}
 
-    pub fn sample(&self, world: &mut W, ctx: SampleCtx) {
-        (self.sample)(world, ctx)
+impl<W, I, S, T> Default for Pipeline<W, I, S, T>
+where
+    W: SubjectSource<I, S>,
+    I: SubjectId,
+    S: 'static,
+    T: Clone + ThreadSafe,
+{
+    fn default() -> Self {
+        Self::new()
     }
 }
 
-#[derive(Resource)]
-pub struct PipelineRegistry<W> {
-    pipelines: HashMap<PipelineKey, Pipeline<W>>,
+#[derive(Debug, Clone, Copy)]
+pub struct PipelineUntyped {
+    bake: BakeFnPtr,
+    sample: SampleFnPtr,
 }
 
-impl<W> PipelineRegistry<W> {
-    pub fn new() -> Self {
-        Self {
-            pipelines: HashMap::new(),
-        }
-    }
-
-    pub fn get(&self, key: &PipelineKey) -> Option<&Pipeline<W>> {
-        self.pipelines.get(key)
-    }
-
-    /// Register a pipeline function.
+impl PipelineUntyped {
+    /// # Safety
     ///
-    /// Registering the same key twice will result in a replacement.
-    ///
-    /// # Note
-    ///
-    /// This function assumes that the baker function matches
-    /// the field that it points towards. Failure to do so will
-    /// result in a useless baker registry.
-    pub fn register_unchecked(
-        &mut self,
-        key: PipelineKey,
-        pipeline: Pipeline<W>,
-    ) -> &mut Self {
-        self.pipelines.insert(key, pipeline);
-        self
+    /// `W` must match the type used when registering this pipeline.
+    pub(crate) unsafe fn bake<W>(&self, ctx: BakeCtx<W>) {
+        let f = unsafe { self.bake.typed_unchecked::<W>() };
+        f(ctx)
     }
-}
 
-impl<W> Default for PipelineRegistry<W> {
-    fn default() -> Self {
-        Self::new()
+    /// # Safety
+    ///
+    /// `W` must match the type used when registering this pipeline.
+    pub(crate) unsafe fn sample<W>(&self, ctx: SampleCtx<W>) {
+        let f = unsafe { self.sample.typed_unchecked::<W>() };
+        f(ctx)
     }
 }
 
-pub struct BakeCtx<'a> {
+pub struct BakeCtx<'a, W> {
+    pub world: &'a W,
     pub track: &'a Track,
     pub action_world: &'a mut ActionWorld,
-    pub accessor_registry: &'a FieldAccessorRegistry,
+    pub accessor_registry: &'a AccessorRegistry,
 }
 
-impl<'a> BakeCtx<'a> {
-    pub fn bake<I, S, T>(
-        self,
-        get_source: impl Fn(I) -> Option<&'a S>,
-    ) where
-        I: SubjectId,
-        S: 'static,
-        T: Clone + ThreadSafe,
-    {
-        for (key, span) in self.track.sequences_spans() {
-            let Ok(accessor) =
-                self.accessor_registry.get::<S, T>(key.field())
-            else {
-                continue;
-            };
+pub fn bake<W, I, S, T>(ctx: BakeCtx<W>)
+where
+    W: SubjectSource<I, S>,
+    I: SubjectId,
+    S: 'static,
+    T: Clone + ThreadSafe,
+{
+    for (key, span) in ctx.track.sequences_spans() {
+        let Some(accessor) =
+            ctx.accessor_registry.get::<S, T>(key.field())
+        else {
+            continue;
+        };
 
-            let Some(&id) =
-                self.action_world.get_id(&key.subject_id().uid())
-            else {
-                continue;
-            };
+        let Some(&id) =
+            ctx.action_world.get_id(&key.subject_id().uid())
+        else {
+            continue;
+        };
 
-            // Get the source from the target world.
-            let Some(source) = get_source(id) else {
-                continue;
-            };
+        let Some(source) = ctx.world.get_source(id) else {
+            continue;
+        };
 
-            let mut start = accessor.get_ref(source).clone();
+        let mut start = accessor.get_ref(source).clone();
 
-            for ActionClip { id, .. } in self.track.clips(*span) {
-                let Some(action) =
-                    self.action_world.get_action::<T>(*id)
-                else {
-                    continue;
-                };
+        for ActionClip { id, .. } in ctx.track.clips(*span) {
+            let Some(action) = ctx.action_world.get_action::<T>(*id)
+            else {
+                continue;
+            };
 
-                let end = action(&start);
-                let segment =
-                    Segment::new(start.clone(), end.clone());
+            let end = action(&start);
+            let segment = Segment::new(start.clone(), end.clone());
 
-                self.action_world
-                    .edit_action(*id)
-                    .set_segment(segment);
+            ctx.action_world.edit_action(*id).set_segment(segment);
 
-                start = end;
-            }
+            start = end;
         }
     }
 }
 
-pub struct SampleCtx<'a> {
+pub struct SampleCtx<'a, W> {
+    pub world: &'a mut W,
     pub action_world: &'a ActionWorld,
-    pub accessor_registry: &'a FieldAccessorRegistry,
+    pub accessor_registry: &'a AccessorRegistry,
 }
 
-impl<'a> SampleCtx<'a> {
-    pub fn sample<I, S, T>(
-        self,
-        mut set_target: impl FnMut(I, T, Accessor<S, T>),
-    ) where
-        I: SubjectId,
-        S: 'static,
-        T: Clone + ThreadSafe,
+pub fn sample<W, I, S, T>(ctx: SampleCtx<W>)
+where
+    W: SubjectSource<I, S>,
+    I: SubjectId,
+    S: 'static,
+    T: Clone + ThreadSafe,
+{
+    let Some(mut q) = ctx.action_world.world().try_query::<(
+        &ActionKey,
+        &SampleMode,
+        &Segment<T>,
+        &InterpStorage<T>,
+        Option<&EaseStorage>,
+    )>() else {
+        return;
+    };
+
+    for (key, sample_mode, segment, interp, ease) in
+        q.iter(ctx.action_world.world())
     {
-        let Some(mut q) = self.action_world.world().try_query::<(
-            &ActionKey,
-            &SampleMode,
-            &Segment<T>,
-            &InterpStorage<T>,
-            Option<&EaseStorage>,
-        )>() else {
-            return;
+        let Some(accessor) =
+            ctx.accessor_registry.get::<S, T>(key.field())
+        else {
+            continue;
         };
 
-        for (key, sample_mode, segment, interp, ease) in
-            q.iter(self.action_world.world())
-        {
-            let Ok(accessor) =
-                self.accessor_registry.get::<S, T>(key.field())
-            else {
-                continue;
-            };
+        let Some(&id) =
+            ctx.action_world.get_id(&key.subject_id().uid())
+        else {
+            continue;
+        };
 
-            let Some(&id) =
-                self.action_world.get_id(&key.subject_id().uid())
-            else {
-                continue;
-            };
+        let target = match sample_mode {
+            SampleMode::Start => segment.start.clone(),
+            SampleMode::End => segment.end.clone(),
+            SampleMode::Interp(t) => {
+                let t = match ease {
+                    Some(ease) => ease.0(*t),
+                    None => *t,
+                };
 
-            let target = match sample_mode {
-                SampleMode::Start => segment.start.clone(),
-                SampleMode::End => segment.end.clone(),
-                SampleMode::Interp(t) => {
-                    let t = match ease {
-                        Some(ease) => ease.0(*t),
-                        None => *t,
-                    };
-
-                    interp.0(&segment.start, &segment.end, t)
-                }
-            };
+                interp.0(&segment.start, &segment.end, t)
+            }
+        };
 
-            set_target(id, target, accessor);
-        }
+        ctx.world.apply_source(id, |source| {
+            *accessor.get_mut(source) = target;
+        });
     }
 }
 
diff --git a/crates/motiongfx/src/pipeline/func_pointers.rs b/crates/motiongfx/src/pipeline/func_pointers.rs
new file mode 100644
index 0000000..8ea1853
--- /dev/null
+++ b/crates/motiongfx/src/pipeline/func_pointers.rs
@@ -0,0 +1,48 @@
+use super::{BakeCtx, SampleCtx};
+
+/// A type-erased bake function pointer.
+#[derive(Debug, Clone, Copy)]
+pub struct BakeFnPtr(*const ());
+
+unsafe impl Send for BakeFnPtr {}
+unsafe impl Sync for BakeFnPtr {}
+
+impl BakeFnPtr {
+    pub const fn new<W>(f: BakeFn<W>) -> Self {
+        Self(f as *const ())
+    }
+
+    /// # Safety
+    ///
+    /// `W` must match the type used when constructing this pointer.
+    pub const unsafe fn typed_unchecked<W>(&self) -> BakeFn<W> {
+        unsafe {
+            core::mem::transmute::<*const (), BakeFn<W>>(self.0)
+        }
+    }
+}
+
+/// A type-erased sample function pointer.
+#[derive(Debug, Clone, Copy)]
+pub struct SampleFnPtr(*const ());
+
+unsafe impl Send for SampleFnPtr {}
+unsafe impl Sync for SampleFnPtr {}
+
+impl SampleFnPtr {
+    pub const fn new<W>(f: SampleFn<W>) -> Self {
+        Self(f as *const ())
+    }
+
+    /// # Safety
+    ///
+    /// `W` must match the type used when constructing this pointer.
+    pub const unsafe fn typed_unchecked<W>(&self) -> SampleFn<W> {
+        unsafe {
+            core::mem::transmute::<*const (), SampleFn<W>>(self.0)
+        }
+    }
+}
+
+pub type BakeFn<W> = fn(BakeCtx<'_, W>);
+pub type SampleFn<W> = fn(SampleCtx<'_, W>);
diff --git a/crates/motiongfx/src/registry.rs b/crates/motiongfx/src/registry.rs
new file mode 100644
index 0000000..ad1dea7
--- /dev/null
+++ b/crates/motiongfx/src/registry.rs
@@ -0,0 +1,169 @@
+use core::any::TypeId;
+
+use bevy_platform::collections::HashMap;
+use field_path::accessor::{Accessor, UntypedAccessor};
+use field_path::field::UntypedField;
+use field_path::field_accessor::FieldAccessor;
+
+use crate::ThreadSafe;
+use crate::pipeline::{
+    BakeCtx, Pipeline, PipelineHandle, PipelineKey, PipelineUntyped,
+    SampleCtx,
+};
+use crate::prelude::{SubjectSource, TimelineBuilder};
+use crate::subject::SubjectId;
+
+pub struct Registry {
+    pub accessor: AccessorRegistry,
+    pub pipeline: PipelineRegistry,
+}
+
+impl Registry {
+    pub fn new() -> Self {
+        Self {
+            accessor: AccessorRegistry::new(),
+            pipeline: PipelineRegistry::new(),
+        }
+    }
+
+    pub fn register<W, I, S, T>(
+        &mut self,
+        field_acc: FieldAccessor<S, T>,
+    ) where
+        W: SubjectSource<I, S> + 'static,
+        I: SubjectId,
+        S: 'static,
+        T: Clone + ThreadSafe,
+    {
+        self.accessor.register(field_acc);
+        self.pipeline.register::<W, I, S, T>();
+    }
+
+    /// Create a [`TimelineBuilder`] for a specific `W` world.
+    pub fn create_builder<W: 'static>(
+        &mut self,
+    ) -> TimelineBuilder<'_, W> {
+        TimelineBuilder::new(self)
+    }
+}
+
+impl Default for Registry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct AccessorRegistry {
+    accessors: HashMap<UntypedField, UntypedAccessor>,
+}
+
+impl AccessorRegistry {
+    pub fn new() -> Self {
+        Self {
+            accessors: HashMap::new(),
+        }
+    }
+
+    /// Registers a [`FieldAccessor`] pair.
+    /// Skips fields already registered.
+    #[inline]
+    pub fn register<S: 'static, T: 'static>(
+        &mut self,
+        field_acc: FieldAccessor<S, T>,
+    ) {
+        let untyped_field = field_acc.field.untyped();
+        if self.accessors.contains_key(&untyped_field) {
+            return;
+        }
+
+        self.accessors
+            .insert(untyped_field, field_acc.accessor.untyped());
+    }
+
+    /// Retrieve a typed [`Accessor`] from the registry.
+    pub fn get<S: 'static, T: 'static>(
+        &self,
+        field: &UntypedField,
+    ) -> Option<Accessor<S, T>> {
+        self.accessors.get(field)?.typed()
+    }
+}
+
+impl Default for AccessorRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct PipelineRegistry {
+    pipelines: HashMap<PipelineKey, PipelineUntyped>,
+}
+
+impl PipelineRegistry {
+    pub fn new() -> Self {
+        Self {
+            pipelines: HashMap::new(),
+        }
+    }
+
+    pub(crate) fn bake<W: 'static>(
+        &self,
+        key: &PipelineKey,
+        ctx: BakeCtx<W>,
+    ) -> bool {
+        if key.world_id() != TypeId::of::<W>() {
+            return false;
+        }
+
+        if let Some(pipeline) = self.pipelines.get(key) {
+            // SAFETY: verified above that key.world_id == TypeId::of::<W>().
+            unsafe { pipeline.bake(ctx) };
+            return true;
+        }
+
+        false
+    }
+
+    pub(crate) fn sample<W: 'static>(
+        &self,
+        key: &PipelineKey,
+        ctx: SampleCtx<W>,
+    ) -> bool {
+        if key.world_id() != TypeId::of::<W>() {
+            return false;
+        }
+
+        if let Some(pipeline) = self.pipelines.get(key) {
+            // SAFETY: verified above that key.world_id == TypeId::of::<W>().
+            unsafe { pipeline.sample(ctx) };
+            return true;
+        }
+
+        false
+    }
+
+    /// Register a [`Pipeline`].
+    /// Skips pipelines already registered.
+    pub fn register<W, I, S, T>(&mut self) -> &mut Self
+    where
+        W: SubjectSource<I, S> + 'static,
+        I: SubjectId,
+        S: 'static,
+        T: Clone + ThreadSafe,
+    {
+        let key = PipelineHandle::<W, I, S, T>::new().as_key();
+        if self.pipelines.contains_key(&key) {
+            return self;
+        }
+
+        self.pipelines
+            .insert(key, Pipeline::<W, I, S, T>::new().untyped());
+        self
+    }
+}
+
+impl Default for PipelineRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/crates/motiongfx/src/timeline.rs b/crates/motiongfx/src/timeline.rs
index 35353ee..643112f 100644
--- a/crates/motiongfx/src/timeline.rs
+++ b/crates/motiongfx/src/timeline.rs
@@ -1,24 +1,23 @@
 use core::cmp::Ordering;
+use core::marker::PhantomData;
 
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 use bevy_platform::collections::HashMap;
-use field_path::field::Field;
-use field_path::registry::FieldAccessorRegistry;
+use field_path::field_accessor::FieldAccessor;
 
 use crate::ThreadSafe;
 use crate::action::{
     Action, ActionBuilder, ActionId, ActionKey, ActionWorld,
     InterpActionBuilder, SampleMode,
 };
-use crate::pipeline::Range;
-use crate::pipeline::{
-    BakeCtx, PipelineKey, PipelineRegistry, SampleCtx,
-};
+use crate::pipeline::{BakeCtx, PipelineKey, Range, SampleCtx};
+use crate::registry::Registry;
 use crate::subject::SubjectId;
 use crate::track::Track;
+use crate::world::SubjectSource;
 
-pub struct Timeline {
+pub struct Timeline<W> {
     action_world: ActionWorld,
     pipeline_counts: Box<[(PipelineKey, u32)]>,
     /// Track length is guaranteed to be at least 1 by construction.
@@ -37,33 +36,42 @@ pub struct Timeline {
     curr_index: usize,
     /// The index of the target track.
     target_index: usize,
+    _marker: PhantomData<fn() -> W>,
 }
 
-impl Timeline {
-    pub fn bake_actions<W>(
+impl<W: 'static> Timeline<W> {
+    pub fn bake_actions(
         &mut self,
-        accessor_registry: &FieldAccessorRegistry,
-        pipeline_registry: &PipelineRegistry<W>,
+        registry: &Registry,
         subject_world: &W,
     ) {
         for key in self.pipeline_counts.iter().map(|(key, _)| key) {
-            let Some(pipeline) = pipeline_registry.get(key) else {
-                continue;
-            };
-
             for track in self.tracks.iter() {
-                pipeline.bake(
-                    subject_world,
+                let ok = registry.pipeline.bake(
+                    key,
                     BakeCtx {
+                        world: subject_world,
                         track,
                         action_world: &mut self.action_world,
-                        accessor_registry,
+                        accessor_registry: &registry.accessor,
                     },
-                )
+                );
+                debug_assert!(
+                    ok,
+                    "pipeline not found for key {key:?}"
+                );
             }
         }
     }
 
+    /// Determines which actions are active at the current target time
+    /// and marks them for sampling.
+    ///
+    /// This step is intentionally separate from
+    /// [`Self::sample_queued_actions`] so that multiple timelines can
+    /// queue concurrently. Queuing only requires `&mut self`, whereas
+    /// sampling requires `&mut W`, which would prevent parallel
+    /// execution across timelines sharing the same world.
     pub fn queue_actions(&mut self) {
         if self.tracks.is_empty() {
             return;
@@ -220,24 +228,21 @@ impl Timeline {
         self.curr_time = self.target_time;
     }
 
-    pub fn sample_queued_actions<W>(
+    pub fn sample_queued_actions(
         &self,
-        accessor_registry: &FieldAccessorRegistry,
-        pipeline_registry: &PipelineRegistry<W>,
+        registry: &Registry,
         subject_world: &mut W,
     ) {
         for key in self.pipeline_counts.iter().map(|(key, _)| key) {
-            let Some(pipeline) = pipeline_registry.get(key) else {
-                continue;
-            };
-
-            pipeline.sample(
-                subject_world,
+            let ok = registry.pipeline.sample(
+                key,
                 SampleCtx {
+                    world: subject_world,
                     action_world: &self.action_world,
-                    accessor_registry,
+                    accessor_registry: &registry.accessor,
                 },
             );
+            debug_assert!(ok, "pipeline not found for key {key:?}");
         }
     }
 
@@ -248,7 +253,7 @@ impl Timeline {
 }
 
 // Getter methods.
-impl Timeline {
+impl<W> Timeline<W> {
     /// Returns the current queue cache.
     #[inline]
     pub fn queue_cache(&self) -> &QueueCache {
@@ -322,7 +327,7 @@ impl Timeline {
 }
 
 // Setter methods.
-impl Timeline {
+impl<W> Timeline<W> {
     /// Set the target time of the current track, clamping the value
     /// within \[0.0..=track.duration\]
     pub fn set_target_time(&mut self, target_time: f32) -> &mut Self {
@@ -406,19 +411,23 @@ impl Default for QueueCache {
     }
 }
 
-pub struct TimelineBuilder {
+pub struct TimelineBuilder<'a, W> {
+    registry: &'a mut Registry,
     action_world: ActionWorld,
     pipeline_counts: HashMap<PipelineKey, u32>,
     tracks: Vec<Track>,
+    _marker: PhantomData<fn() -> W>,
 }
 
-impl TimelineBuilder {
+impl<'a, W: 'static> TimelineBuilder<'a, W> {
     /// Creates an empty timeline builder.
-    pub fn new() -> Self {
+    pub fn new(registry: &'a mut Registry) -> Self {
         Self {
+            registry,
             action_world: ActionWorld::new(),
             pipeline_counts: HashMap::new(),
             tracks: Vec::new(),
+            _marker: PhantomData,
         }
     }
 
@@ -426,15 +435,18 @@ impl TimelineBuilder {
     pub fn act<I, S, T>(
         &mut self,
         target: I,
-        field: Field<S, T>,
+        field_acc: FieldAccessor<S, T>,
         action: impl Action<T>,
     ) -> ActionBuilder<'_, T>
     where
+        W: SubjectSource<I, S> + 'static,
         I: SubjectId,
         S: 'static,
-        T: ThreadSafe,
+        T: Clone + ThreadSafe,
     {
-        let key = PipelineKey::new::<I, S, T>();
+        let field = field_acc.field;
+        self.registry.register::<W, I, S, T>(field_acc);
+        let key = PipelineKey::new::<W, I, S, T>();
 
         match self.pipeline_counts.get_mut(&key) {
             Some(count) => *count += 1,
@@ -450,15 +462,16 @@ impl TimelineBuilder {
     pub fn act_step<I, S, T>(
         &mut self,
         target: I,
-        field: Field<S, T>,
+        field_acc: FieldAccessor<S, T>,
         action: impl Action<T>,
     ) -> InterpActionBuilder<'_, T>
     where
+        W: SubjectSource<I, S> + 'static,
         I: SubjectId,
         S: 'static,
         T: Clone + ThreadSafe,
     {
-        self.act(target, field, action).with_interp(|a, b, t| {
+        self.act(target, field_acc, action).with_interp(|a, b, t| {
             if t < 1.0 { a.clone() } else { b.clone() }
         })
     }
@@ -466,7 +479,7 @@ impl TimelineBuilder {
     /// Remove an [`Action`].
     pub fn unact(&mut self, id: ActionId) -> bool {
         if let Some(key) = self.action_world.remove(id) {
-            let pipeline_key = PipelineKey::from_action_key(key);
+            let pipeline_key = PipelineKey::from_action_key::<W>(key);
 
             let count = self
                 .pipeline_counts
@@ -502,7 +515,10 @@ impl TimelineBuilder {
     /// ## Panic
     ///
     /// Panics if the track is empty.
-    pub fn compile(self) -> Timeline {
+    /// Use [`Self::try_compile`] to explicitly handle the case where
+    /// the track may be empty.
+    pub fn compile(self) -> Timeline<W> {
+        // TODO(nixon): What happens when track is empty?
         debug_assert!(
             !self.tracks.is_empty(),
             "Track cannot be empty!"
@@ -520,19 +536,14 @@ impl TimelineBuilder {
             target_time: 0.0,
             curr_index: 0,
             target_index: 0,
+            _marker: PhantomData,
         }
     }
 
-    /// Similar to [`Self::compile()`] but return `None` instead of
+    /// Similar to [`Self::compile`] but return `None` instead of
     /// panicking.
-    pub fn try_compile(self) -> Option<Timeline> {
-        (!self.tracks.is_empty()).then_some(self.compile())
-    }
-}
-
-impl Default for TimelineBuilder {
-    fn default() -> Self {
-        Self::new()
+    pub fn try_compile(self) -> Option<Timeline<W>> {
+        (!self.tracks.is_empty()).then(|| self.compile())
     }
 }
 
diff --git a/crates/motiongfx/src/track.rs b/crates/motiongfx/src/track.rs
index aa157ca..1f3c145 100644
--- a/crates/motiongfx/src/track.rs
+++ b/crates/motiongfx/src/track.rs
@@ -352,7 +352,7 @@ mod tests {
 
     fn key(path: &'static str) -> ActionKey {
         ActionKey::new(
-            UntypedSubjectId::placeholder(),
+            UntypedSubjectId::PLACEHOLDER,
             UntypedField::placeholder_with_path(path),
         )
     }
diff --git a/crates/motiongfx/src/world.rs b/crates/motiongfx/src/world.rs
new file mode 100644
index 0000000..f2efd61
--- /dev/null
+++ b/crates/motiongfx/src/world.rs
@@ -0,0 +1,12 @@
+use crate::subject::SubjectId;
+
+/// Provides read and write access to a source type `S` by subject id `I`.
+pub trait SubjectSource<I: SubjectId, S: 'static> {
+    fn get_source(&self, id: I) -> Option<&S>;
+
+    fn apply_source<R>(
+        &mut self,
+        id: I,
+        f: impl FnOnce(&mut S) -> R,
+    ) -> Option<R>;
+}
diff --git a/examples/bevy_examples/examples/custom_ease.rs b/examples/bevy_examples/examples/custom_ease.rs
index 2b034a8..1bb9468 100644
--- a/examples/bevy_examples/examples/custom_ease.rs
+++ b/examples/bevy_examples/examples/custom_ease.rs
@@ -14,29 +14,32 @@ fn main() {
 
 fn spawn_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     // Spawn cube.
-    let cube = commands
+    let cube_id = commands
         .spawn((
             Mesh3d(meshes.add(Cuboid::default())),
-            MeshMaterial3d(materials.add(StandardMaterial {
-                base_color: palettes::tailwind::LIME_200.into(),
-                ..default()
-            })),
+            MeshMaterial3d(materials.add(
+                StandardMaterial::from_color(
+                    palettes::tailwind::LIME_200,
+                ),
+            )),
             Transform::from_xyz(-5.0, 0.0, 0.0),
         ))
         .id();
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
 
     let track = b
-        .act_interp(cube, field!(<Transform>::translation::x), |x| {
-            x + 10.0
-        })
+        .act_interp(
+            cube_id,
+            path!(<Transform>::translation::x),
+            |x| x + 10.0,
+        )
         // A custom 10 step easing.
         .with_ease(|t| ((t * 10.0) as u32) as f32 / 10.0)
         .play(1.0)
@@ -44,8 +47,9 @@ fn spawn_timeline(
 
     b.add_tracks(track);
 
+    let timeline = b.compile();
     commands.spawn((
-        motiongfx.add_timeline(b.compile()),
+        motiongfx.add_timeline(timeline),
         RealtimePlayer::new().with_playing(true),
     ));
 }
diff --git a/examples/bevy_examples/examples/custom_interp.rs b/examples/bevy_examples/examples/custom_interp.rs
index 6130c98..60b975e 100644
--- a/examples/bevy_examples/examples/custom_interp.rs
+++ b/examples/bevy_examples/examples/custom_interp.rs
@@ -16,27 +16,28 @@ fn main() {
 
 fn spawn_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     // Spawn cube.
-    let cube = commands
+    let cube_id = commands
         .spawn((
             Mesh3d(meshes.add(Cuboid::default())),
-            MeshMaterial3d(materials.add(StandardMaterial {
-                base_color: palettes::tailwind::LIME_200.into(),
-                ..default()
-            })),
+            MeshMaterial3d(materials.add(
+                StandardMaterial::from_color(
+                    palettes::tailwind::LIME_200,
+                ),
+            )),
             Transform::from_xyz(-5.0, 0.0, 0.0),
         ))
         .id();
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
 
     let track = b
-        .act(cube, field!(<Transform>::translation), |x| {
+        .act(cube_id, path!(<Transform>::translation), |x| {
             x + Vec3::ZERO.with_x(10.0).with_z(1.0)
         })
         .with_interp(|start, end, t| arc_lerp_3d(*start, *end, t))
@@ -46,9 +47,10 @@ fn spawn_timeline(
 
     b.add_tracks(track);
 
+    let timeline = b.compile();
     commands.spawn((
-        motiongfx.add_timeline(b.compile()),
-        RealtimePlayer::new(),
+        motiongfx.add_timeline(timeline),
+        RealtimePlayer::new().with_playing(true),
     ));
 }
 
@@ -71,7 +73,7 @@ fn setup(mut commands: Commands) {
     ));
 }
 
-// TODO: Optimize this.
+// TODO(nixon): Optimize this.
 pub fn arc_lerp_3d(start: Vec3, end: Vec3, t: f32) -> Vec3 {
     let center = (start + end) * 0.5;
 
diff --git a/examples/bevy_examples/examples/easings.rs b/examples/bevy_examples/examples/easings.rs
index 61a7bc6..177a6eb 100644
--- a/examples/bevy_examples/examples/easings.rs
+++ b/examples/bevy_examples/examples/easings.rs
@@ -17,7 +17,7 @@ fn main() {
 
 fn spawn_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
@@ -41,8 +41,8 @@ fn spawn_timeline(
     let red = LinearRgba::from(palettes::tailwind::ROSE_400) * 100.0;
 
     // Spawn spheres.
-    let mut spheres = Vec::with_capacity(capacity);
-    let mut sphere_mats = Vec::with_capacity(capacity);
+    let mut sphere_ids = Vec::with_capacity(capacity);
+    let mut sphere_mat_ids = Vec::with_capacity(capacity);
     let mesh_handle = meshes.add(Sphere::default());
     let material = StandardMaterial {
         base_color: Color::WHITE,
@@ -51,11 +51,12 @@ fn spawn_timeline(
     };
 
     for i in 0..capacity {
-        let sphere_mat = materials.add(material.clone());
+        let sphere_mat_handle = materials.add(material.clone());
+        let sphere_mat_id = sphere_mat_handle.id().untyped();
         let sphere = commands
             .spawn((
                 Mesh3d(mesh_handle.clone()),
-                MeshMaterial3d(sphere_mat.clone()),
+                MeshMaterial3d(sphere_mat_handle),
                 Transform::from_translation(Vec3::new(
                     -5.0,
                     (i as f32) - (capacity as f32) * 0.5,
@@ -66,29 +67,28 @@ fn spawn_timeline(
             ))
             .id();
 
-        spheres.push(sphere);
-        sphere_mats.push(sphere_mat.untyped().id());
+        sphere_ids.push(sphere);
+        sphere_mat_ids.push(sphere_mat_id);
     }
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
 
     let track = easings
         .into_iter()
         .enumerate()
-        // .zip(easings)
         .map(|(i, ease_fn)| {
             [
                 b.act_interp(
-                    spheres[i],
-                    field!(<Transform>::translation::x),
+                    sphere_ids[i],
+                    path!(<Transform>::translation::x),
                     |x| x + 10.0,
                 )
                 .with_ease(ease_fn)
                 .play(1.0),
                 b.act_interp(
-                    sphere_mats[i],
-                    field!(<StandardMaterial>::emissive),
+                    sphere_mat_ids[i],
+                    path!(<StandardMaterial>::emissive),
                     move |_| red,
                 )
                 .with_ease(ease_fn)
@@ -100,8 +100,9 @@ fn spawn_timeline(
 
     b.add_tracks(track.compile());
 
+    let timeline = b.compile();
     commands.spawn((
-        motiongfx.add_timeline(b.compile()),
+        motiongfx.add_timeline(timeline),
         RealtimePlayer::new().with_playing(true),
     ));
 }
diff --git a/examples/bevy_examples/examples/hello_world.rs b/examples/bevy_examples/examples/hello_world.rs
index 45807e3..90001ea 100644
--- a/examples/bevy_examples/examples/hello_world.rs
+++ b/examples/bevy_examples/examples/hello_world.rs
@@ -15,7 +15,7 @@ fn main() {
 
 fn spawn_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut meshes: ResMut<Assets<Mesh>>,
 ) {
@@ -25,12 +25,11 @@ fn spawn_timeline(
     const CAPACITY: usize = WIDTH * HEIGHT;
 
     // Spawn cubes.
-    let mut cubes = Vec::with_capacity(CAPACITY);
+    let mut cube_ids = Vec::with_capacity(CAPACITY);
     let mesh_handle = meshes.add(Cuboid::default());
-    let material_handle = materials.add(StandardMaterial {
-        base_color: palettes::tailwind::LIME_200.into(),
-        ..default()
-    });
+    let material_handle = materials.add(
+        StandardMaterial::from_color(palettes::tailwind::LIME_200),
+    );
 
     for w in 0..WIDTH {
         for h in 0..HEIGHT {
@@ -48,39 +47,39 @@ fn spawn_timeline(
                     MeshMaterial3d(material_handle.clone()),
                 ))
                 .id();
-            cubes.push(id);
+            cube_ids.push(id);
         }
     }
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
     let mut cube_tracks = Vec::with_capacity(CAPACITY);
 
     for w in 0..WIDTH {
         for h in 0..HEIGHT {
             let c = w * WIDTH + h;
-            let cube = cubes[c];
+            let cube_id = cube_ids[c];
 
             let circ_ease = ease::circ::ease_in_out;
 
             let track = [
                 b.act_interp(
-                    cube,
-                    field!(<Transform>::scale),
+                    cube_id,
+                    path!(<Transform>::scale),
                     |_| Vec3::splat(0.9),
                 )
                 .with_ease(circ_ease)
                 .play(1.0),
                 b.act_interp(
-                    cube,
-                    field!(<Transform>::translation::x),
+                    cube_id,
+                    path!(<Transform>::translation::x),
                     |x| x + 1.0,
                 )
                 .with_ease(circ_ease)
                 .play(1.0),
                 b.act_interp(
-                    cube,
-                    field!(<Transform>::rotation),
+                    cube_id,
+                    path!(<Transform>::rotation),
                     |_| {
                         Quat::from_euler(
                             EulerRot::XYZ,
diff --git a/examples/bevy_examples/examples/minimal.rs b/examples/bevy_examples/examples/minimal.rs
index 4dcca8f..7b36056 100644
--- a/examples/bevy_examples/examples/minimal.rs
+++ b/examples/bevy_examples/examples/minimal.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 use bevy_motiongfx::BevyMotionGfxPlugin;
+use bevy_motiongfx::manager::TimelineComplete;
 use bevy_motiongfx::prelude::*;
-use bevy_motiongfx::world::TimelineComplete;
 
 fn main() {
     App::new()
@@ -32,33 +32,34 @@ fn log_complete(_: On<Add, TimelineComplete>) {
 /// Creates the timeline and plays it.
 fn build_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    let material =
+    let cube_mat_handle =
         materials.add(StandardMaterial::from_color(Srgba::BLUE));
+    let cube_mat_id = cube_mat_handle.id().untyped();
     // Spawns the cube.
-    let cube = commands
+    let cube_id = commands
         .spawn((
             Mesh3d(meshes.add(Cuboid::default())),
-            MeshMaterial3d(material.clone()),
+            MeshMaterial3d(cube_mat_handle),
             Transform::from_xyz(-3.0, 0.0, 0.0),
         ))
         .id();
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
     let track = [
         b.act_interp(
-            cube,
-            field!(<Transform>::translation::x),
+            cube_id,
+            path!(<Transform>::translation::x),
             |x| x + 6.0,
         )
         .play(1.0),
         b.act_interp(
-            material.untyped().id(),
-            field!(<StandardMaterial>::base_color),
+            cube_mat_id,
+            path!(<StandardMaterial>::base_color),
             |_| Srgba::RED.into(),
         )
         .play(1.0),
diff --git a/examples/bevy_examples/examples/recording.rs b/examples/bevy_examples/examples/recording.rs
index 10d2eab..b767b43 100644
--- a/examples/bevy_examples/examples/recording.rs
+++ b/examples/bevy_examples/examples/recording.rs
@@ -4,8 +4,8 @@ use bevy::color::palettes;
 use bevy::prelude::*;
 use bevy::render::view::screenshot::{Screenshot, save_to_disk};
 use bevy_motiongfx::BevyMotionGfxPlugin;
+use bevy_motiongfx::manager::TimelineComplete;
 use bevy_motiongfx::prelude::*;
-use bevy_motiongfx::world::TimelineComplete;
 
 use crate::pipelines_ready::*;
 
@@ -87,30 +87,28 @@ fn check_final_frame(
 
 fn spawn_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     // Spawn cube.
-    let mesh = meshes.add(Cuboid::default());
-    let mat = materials.add(StandardMaterial {
-        base_color: palettes::tailwind::LIME_200.into(),
-        ..default()
-    });
-
-    let cube = commands
+    let cube_id = commands
         .spawn((
-            Mesh3d(mesh),
-            MeshMaterial3d(mat),
+            Mesh3d(meshes.add(Cuboid::default())),
+            MeshMaterial3d(materials.add(
+                StandardMaterial::from_color(
+                    palettes::tailwind::LIME_200,
+                ),
+            )),
             Transform::from_xyz(-5.0, 0.0, 0.0),
         ))
         .id();
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
 
     let track = b
-        .act(cube, field!(<Transform>::translation), |x| {
+        .act(cube_id, path!(<Transform>::translation), |x| {
             x + Vec3::ZERO.with_x(10.0).with_z(1.0)
         })
         .with_interp(|start, end, t| arc_lerp_3d(*start, *end, t))
@@ -119,8 +117,9 @@ fn spawn_timeline(
 
     b.add_tracks(track);
 
+    let timeline = b.compile();
     commands.spawn((
-        motiongfx.add_timeline(b.compile()),
+        motiongfx.add_timeline(timeline),
         FixedRatePlayer::new(144),
     ));
 }
diff --git a/examples/bevy_examples/examples/slide_basic.rs b/examples/bevy_examples/examples/slide_basic.rs
index 9d6e000..b81c514 100644
--- a/examples/bevy_examples/examples/slide_basic.rs
+++ b/examples/bevy_examples/examples/slide_basic.rs
@@ -14,21 +14,22 @@ fn main() {
 
 fn spawn_timeline(
     mut commands: Commands,
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     const X_OFFSET: f32 = 2.0;
 
     // Spawn 3d models.
+    let cube_mat_handle = materials.add(
+        StandardMaterial::from_color(palettes::tailwind::LIME_200),
+    );
+    let cube_mat_id = cube_mat_handle.id().untyped();
     let cube = commands
         .spawn((
             Mesh3d(meshes.add(Cuboid::default())),
             Transform::default().with_scale(Vec3::splat(0.0)),
-            MeshMaterial3d(materials.add(StandardMaterial {
-                base_color: palettes::tailwind::LIME_200.into(),
-                ..default()
-            })),
+            MeshMaterial3d(cube_mat_handle),
         ))
         .id();
 
@@ -46,11 +47,11 @@ fn spawn_timeline(
         .id();
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_builder();
 
     // Generate slide sequences.
     let slide0 = b
-        .act_interp(cube, field!(<Transform>::scale), |_| Vec3::ONE)
+        .act_interp(cube, path!(<Transform>::scale), |_| Vec3::ONE)
         .with_ease(ease::cubic::ease_out)
         .play(1.0)
         .compile();
@@ -59,21 +60,21 @@ fn spawn_timeline(
         [
             b.act_interp(
                 cube,
-                field!(<Transform>::translation::x),
+                path!(<Transform>::translation::x),
                 move |_| -X_OFFSET,
             )
             .with_ease(ease::cubic::ease_out)
             .play(1.0),
             b.act_interp(
-                cube,
-                field!(<StandardMaterial>::base_color),
+                cube_mat_id,
+                path!(<StandardMaterial>::base_color),
                 move |_| palettes::tailwind::ZINC_700.into(),
             )
             .with_ease(ease::cubic::ease_out)
             .play(1.0),
         ]
         .ord_all(),
-        b.act_interp(sphere, field!(<Transform>::scale), |_| {
+        b.act_interp(sphere, path!(<Transform>::scale), |_| {
             Vec3::ONE
         })
         .with_ease(ease::cubic::ease_out)
@@ -84,8 +85,9 @@ fn spawn_timeline(
 
     b.add_tracks([slide0, slide1]);
 
+    let timeline = b.compile();
     commands.spawn((
-        motiongfx.add_timeline(b.compile()),
+        motiongfx.add_timeline(timeline),
         RealtimePlayer::new().with_playing(true),
     ));
 }
@@ -109,7 +111,7 @@ fn setup(mut commands: Commands) {
 }
 
 fn slide_movement(
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut q_timelines: Query<(&TimelineId, &mut RealtimePlayer)>,
     keys: Res<ButtonInput<KeyCode>>,
 ) {
diff --git a/examples/bevy_examples/src/lib.rs b/examples/bevy_examples/src/lib.rs
index 88324dc..191c33f 100644
--- a/examples/bevy_examples/src/lib.rs
+++ b/examples/bevy_examples/src/lib.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 use bevy_motiongfx::prelude::*;
 
 pub fn timeline_movement(
-    mut motiongfx: ResMut<MotionGfxWorld>,
+    mut motiongfx: ResMut<MotionGfxManager>,
     mut q_timelines: Query<(&TimelineId, &mut RealtimePlayer)>,
     keys: Res<ButtonInput<KeyCode>>,
     time: Res<Time>,