diff --git a/Cargo.toml b/Cargo.toml
index bc85084c68c6f..05e5a6fb1e76f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -126,6 +126,14 @@ path = "examples/3d/texture.rs"
 name = "z_sort_debug"
 path = "examples/3d/z_sort_debug.rs"
 
+[[example]]
+name = "animation_2d"
+path = "examples/animation/animation_2d.rs"
+
+[[example]]
+name = "animation_custom"
+path = "examples/animation/animation_custom.rs"
+
 [[example]]
 name = "custom_loop"
 path = "examples/app/custom_loop.rs"
@@ -359,4 +367,3 @@ icon = "@mipmap/ic_launcher"
 build_targets = ["aarch64-linux-android", "armv7-linux-androideabi"]
 min_sdk_version = 16
 target_sdk_version = 29
-
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
new file mode 100644
index 0000000000000..e119a62752378
--- /dev/null
+++ b/crates/bevy_animation/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "bevy_animation"
+version = "0.3.0"
+edition = "2018"
+authors = ["Bevy Contributors <bevyengine@gmail.com>", "Carter Anderson <mcanders1@gmail.com>"]
+description = "Provides spline animation functionality for Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bevy_core = { path = "../bevy_core", version = "0.3.0" }
+bevy_math = { path = "../bevy_math", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.3.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
+bevy_render = { path = "../bevy_render", version = "0.3.0" }
+bevy_property = { path = "../bevy_property", version = "0.3.0" }
+
+splines = { version = "3.5.0", features = ["serialization", "impl-glam"] }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
new file mode 100644
index 0000000000000..9b1315963574d
--- /dev/null
+++ b/crates/bevy_animation/src/lib.rs
@@ -0,0 +1,25 @@
+pub mod plugin;
+pub mod spline_group;
+pub mod vec3_option;
+
+pub mod spline_groups {
+    pub mod one;
+    pub mod three;
+    pub mod transform;
+}
+
+pub use plugin::AnimationPlugin;
+
+pub mod prelude {
+    pub use crate::{
+        plugin::AnimationPlugin,
+        spline_group::{LoopStyle, SplineGroup},
+        spline_groups::{
+            one::AnimationSplineOne,
+            three::AnimationSplineThree,
+            transform::{AnimationSplineTransform, SplineQuatExt},
+        },
+        vec3_option::Vec3Option,
+    };
+    pub use splines::{Interpolate, Interpolation, Key, Spline};
+}
diff --git a/crates/bevy_animation/src/plugin.rs b/crates/bevy_animation/src/plugin.rs
new file mode 100644
index 0000000000000..f14097eff7b01
--- /dev/null
+++ b/crates/bevy_animation/src/plugin.rs
@@ -0,0 +1,55 @@
+use crate::{
+    spline_group::SplineGroup,
+    spline_groups::{
+        one::AnimationSplineOne, three::AnimationSplineThree, transform::AnimationSplineTransform,
+    },
+};
+
+use bevy_app::{AppBuilder, Plugin};
+use bevy_core::Time;
+use bevy_ecs::{IntoSystem, Query, Res};
+use bevy_math::Vec3;
+use bevy_transform::components::Transform;
+
+#[derive(Default)]
+pub struct AnimationPlugin;
+
+impl Plugin for AnimationPlugin {
+    fn build(&self, app: &mut AppBuilder) {
+        app.add_system(advance_animation_spline)
+            .add_system(advance_animation_spline_three.system())
+            .add_system(advance_animation_transform.system());
+    }
+}
+
+fn advance_animation_spline(time: Res<Time>, mut q: Query<&mut AnimationSplineOne>) {
+    for mut animation_spline in q.iter_mut() {
+        animation_spline.advance(time.delta_seconds);
+    }
+}
+
+fn advance_animation_spline_three(time: Res<Time>, mut q: Query<&mut AnimationSplineThree>) {
+    for mut animation_spline in q.iter_mut() {
+        animation_spline.advance(time.delta_seconds);
+    }
+}
+
+fn advance_animation_transform(
+    time: Res<Time>,
+    mut q: Query<(&mut Transform, &mut AnimationSplineTransform)>,
+) {
+    for (mut transform, mut splines) in q.iter_mut() {
+        let mut scale = transform.scale;
+        splines.advance(time.delta_seconds);
+        let sample = splines.current();
+        sample.translation.alter(&mut transform.translation);
+        if let Some(sample_scale) = sample.scale {
+            scale = Vec3::one() * sample_scale;
+        }
+        *transform = Transform::from_translation(transform.translation);
+        if let Some(rotation) = sample.rotation {
+            transform.rotation = rotation;
+        }
+        transform.apply_non_uniform_scale(scale);
+    }
+}
diff --git a/crates/bevy_animation/src/spline_group.rs b/crates/bevy_animation/src/spline_group.rs
new file mode 100644
index 0000000000000..279ba04a6385f
--- /dev/null
+++ b/crates/bevy_animation/src/spline_group.rs
@@ -0,0 +1,127 @@
+use core::time::Duration;
+use splines::Spline;
+
+pub(crate) trait SplineExt {
+    fn start_time(&self) -> Option<f32>;
+    fn end_time(&self) -> Option<f32>;
+}
+
+impl<V> SplineExt for Spline<f32, V> {
+    fn start_time(&self) -> Option<f32> {
+        self.keys().first().map(|k| k.t)
+    }
+
+    fn end_time(&self) -> Option<f32> {
+        self.keys().last().map(|k| k.t)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum LoopStyle {
+    Once,
+    Loop,
+    PingPong,
+}
+
+pub trait SplineGroup {
+    type Sample;
+
+    fn loop_style(&self) -> LoopStyle;
+    fn loop_style_mut(&mut self) -> &mut LoopStyle;
+
+    fn time(&self) -> f32;
+    fn time_mut(&mut self) -> &mut f32;
+
+    fn speed(&self) -> f32;
+    fn speed_mut(&mut self) -> &mut f32;
+
+    fn paused(&self) -> bool;
+    fn paused_mut(&mut self) -> &mut bool;
+
+    fn pong(&self) -> bool;
+    fn pong_mut(&mut self) -> &mut bool;
+
+    fn sample(&self, time: f32) -> Self::Sample;
+
+    fn current(&self) -> Self::Sample {
+        self.sample(self.time())
+    }
+
+    fn is_empty(&self) -> bool;
+
+    fn start_time(&self) -> Option<f32>;
+
+    fn end_time(&self) -> Option<f32>;
+
+    fn duration(&self) -> Option<Duration> {
+        self.start_time()
+            .zip(self.end_time())
+            .map(|(start, end)| (start - end).abs())
+            .map(Duration::from_secs_f32)
+    }
+
+    fn advance(&mut self, delta_time: f32) {
+        if self.is_empty() || self.paused() {
+            return;
+        }
+
+        let start = self.start_time().unwrap();
+        let end = self.end_time().unwrap();
+        let direction = self.speed().signum();
+        let reversed = direction < 0.0;
+        let past_boundary = match (reversed, self.pong()) {
+            (true, true) => end < self.time(),
+            (true, false) => start > self.time(),
+            (false, true) => start > self.time(),
+            (false, false) => end < self.time(),
+        };
+
+        let loop_time_start = if reversed { end } else { start };
+        let pong_signum = if self.pong() { -1.0 } else { 1.0 };
+
+        let speed = self.speed();
+        let loop_style = self.loop_style();
+        let pong = self.pong();
+        let time = self.time_mut();
+
+        let mut new_pong = pong;
+
+        match loop_style {
+            LoopStyle::Once => {
+                if !past_boundary {
+                    *time += delta_time * speed;
+                }
+            }
+            LoopStyle::Loop => {
+                if !past_boundary {
+                    *time += delta_time * speed;
+                } else {
+                    *time = loop_time_start;
+                }
+            }
+            LoopStyle::PingPong => {
+                if !past_boundary {
+                    *time += delta_time * speed * pong_signum;
+                } else {
+                    new_pong = !pong;
+                    *time = if new_pong { end } else { start };
+                }
+            }
+        };
+
+        *self.pong_mut() = new_pong;
+    }
+
+    fn pause(&mut self) {
+        *self.paused_mut() = true;
+    }
+
+    fn play(&mut self) {
+        *self.paused_mut() = false;
+    }
+
+    fn toggle_pause(&mut self) {
+        let paused = self.paused();
+        *self.paused_mut() = !paused;
+    }
+}
diff --git a/crates/bevy_animation/src/spline_groups/one.rs b/crates/bevy_animation/src/spline_groups/one.rs
new file mode 100644
index 0000000000000..c514026863f18
--- /dev/null
+++ b/crates/bevy_animation/src/spline_groups/one.rs
@@ -0,0 +1,84 @@
+use crate::spline_group::{LoopStyle, SplineExt, SplineGroup};
+use splines::Spline;
+
+pub struct AnimationSplineOne {
+    pub spline: Spline<f32, f32>,
+    pub loop_style: LoopStyle,
+    pub time: f32,
+    pub speed: f32,
+    pub paused: bool,
+    pub pong: bool,
+}
+
+impl Default for AnimationSplineOne {
+    fn default() -> Self {
+        Self {
+            spline: Spline::from_vec(vec![]),
+            loop_style: LoopStyle::Once,
+            time: 0.0,
+            speed: 1.0,
+            paused: false,
+            pong: false,
+        }
+    }
+}
+
+impl SplineGroup for AnimationSplineOne {
+    type Sample = Option<f32>;
+
+    fn is_empty(&self) -> bool {
+        self.spline.is_empty()
+    }
+
+    fn start_time(&self) -> Option<f32> {
+        self.spline.start_time()
+    }
+
+    fn end_time(&self) -> Option<f32> {
+        self.spline.end_time()
+    }
+
+    fn loop_style(&self) -> LoopStyle {
+        self.loop_style
+    }
+
+    fn loop_style_mut(&mut self) -> &mut LoopStyle {
+        &mut self.loop_style
+    }
+
+    fn time(&self) -> f32 {
+        self.time
+    }
+
+    fn time_mut(&mut self) -> &mut f32 {
+        &mut self.time
+    }
+
+    fn speed(&self) -> f32 {
+        self.speed
+    }
+
+    fn speed_mut(&mut self) -> &mut f32 {
+        &mut self.speed
+    }
+
+    fn paused(&self) -> bool {
+        self.paused
+    }
+
+    fn paused_mut(&mut self) -> &mut bool {
+        &mut self.paused
+    }
+
+    fn pong(&self) -> bool {
+        self.pong
+    }
+
+    fn pong_mut(&mut self) -> &mut bool {
+        &mut self.pong
+    }
+
+    fn sample(&self, time: f32) -> Self::Sample {
+        self.spline.sample(time)
+    }
+}
diff --git a/crates/bevy_animation/src/spline_groups/three.rs b/crates/bevy_animation/src/spline_groups/three.rs
new file mode 100644
index 0000000000000..9ddc7f8bd948f
--- /dev/null
+++ b/crates/bevy_animation/src/spline_groups/three.rs
@@ -0,0 +1,110 @@
+use crate::{
+    spline_group::{LoopStyle, SplineExt, SplineGroup},
+    vec3_option::Vec3Option,
+};
+use splines::Spline;
+
+pub struct AnimationSplineThree {
+    pub x: Spline<f32, f32>,
+    pub y: Spline<f32, f32>,
+    pub z: Spline<f32, f32>,
+    pub loop_style: LoopStyle,
+    pub time: f32,
+    pub speed: f32,
+    pub paused: bool,
+    pub pong: bool,
+}
+
+impl Default for AnimationSplineThree {
+    fn default() -> Self {
+        Self {
+            x: Spline::from_vec(vec![]),
+            y: Spline::from_vec(vec![]),
+            z: Spline::from_vec(vec![]),
+            loop_style: LoopStyle::Once,
+            time: 0.0,
+            speed: 1.0,
+
+            paused: false,
+            pong: false,
+        }
+    }
+}
+
+fn cmp_f32(a: &f32, b: &f32) -> std::cmp::Ordering {
+    a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)
+}
+
+impl SplineGroup for AnimationSplineThree {
+    type Sample = Vec3Option;
+
+    fn is_empty(&self) -> bool {
+        self.x.is_empty() && self.y.is_empty() && self.z.is_empty()
+    }
+
+    fn start_time(&self) -> Option<f32> {
+        self.x
+            .start_time()
+            .into_iter()
+            .chain(self.y.start_time())
+            .chain(self.z.start_time())
+            .min_by(cmp_f32)
+    }
+
+    fn end_time(&self) -> Option<f32> {
+        self.x
+            .end_time()
+            .into_iter()
+            .chain(self.y.end_time())
+            .chain(self.z.end_time())
+            .max_by(cmp_f32)
+    }
+
+    fn loop_style(&self) -> LoopStyle {
+        self.loop_style
+    }
+
+    fn loop_style_mut(&mut self) -> &mut LoopStyle {
+        &mut self.loop_style
+    }
+
+    fn time(&self) -> f32 {
+        self.time
+    }
+
+    fn time_mut(&mut self) -> &mut f32 {
+        &mut self.time
+    }
+
+    fn speed(&self) -> f32 {
+        self.speed
+    }
+
+    fn speed_mut(&mut self) -> &mut f32 {
+        &mut self.speed
+    }
+
+    fn paused(&self) -> bool {
+        self.paused
+    }
+
+    fn paused_mut(&mut self) -> &mut bool {
+        &mut self.paused
+    }
+
+    fn pong(&self) -> bool {
+        self.pong
+    }
+
+    fn pong_mut(&mut self) -> &mut bool {
+        &mut self.pong
+    }
+
+    fn sample(&self, time: f32) -> Self::Sample {
+        Vec3Option::new(
+            self.x.sample(time),
+            self.y.sample(time),
+            self.z.sample(time),
+        )
+    }
+}
diff --git a/crates/bevy_animation/src/spline_groups/transform.rs b/crates/bevy_animation/src/spline_groups/transform.rs
new file mode 100644
index 0000000000000..c748f108bf250
--- /dev/null
+++ b/crates/bevy_animation/src/spline_groups/transform.rs
@@ -0,0 +1,300 @@
+use crate::{
+    spline_group::{LoopStyle, SplineExt, SplineGroup},
+    vec3_option::Vec3Option,
+};
+use bevy_math::Quat;
+use splines::{Interpolation, Key, Spline};
+
+/// A wrapper for a `Quat`, which represents the orientation of an animation keyframe.
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+struct SlerpWrapper(Quat);
+
+impl std::ops::Add<Self> for SlerpWrapper {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        #[allow(clippy::suspicious_arithmetic_impl)]
+        Self(self.0 * other.0)
+    }
+}
+
+impl std::ops::Sub<Self> for SlerpWrapper {
+    type Output = Self;
+
+    fn sub(self, other: Self) -> Self {
+        #[allow(clippy::suspicious_arithmetic_impl)]
+        Self(self.0 * other.0.conjugate())
+    }
+}
+
+impl splines::interpolate::Linear<f32> for SlerpWrapper {
+    fn outer_mul(self, t: f32) -> Self {
+        Self(Quat::identity().slerp(self.0, t))
+    }
+
+    fn outer_div(self, t: f32) -> Self {
+        self.outer_mul(1.0 / t)
+    }
+}
+
+impl splines::Interpolate<f32> for SlerpWrapper {
+    fn lerp(Self(a): Self, Self(b): Self, t: f32) -> Self {
+        Self(a.slerp(b, t))
+    }
+
+    fn quadratic_bezier(_: Self, _: Self, _: Self, _: f32) -> Self {
+        todo!()
+    }
+
+    fn cubic_bezier(_: Self, _: Self, _: Self, _: Self, _: f32) -> Self {
+        todo!()
+    }
+}
+
+impl Into<Quat> for SlerpWrapper {
+    fn into(self) -> Quat {
+        self.0
+    }
+}
+
+impl AsRef<Quat> for SlerpWrapper {
+    fn as_ref(&self) -> &Quat {
+        &self.0
+    }
+}
+
+impl AsMut<Quat> for SlerpWrapper {
+    fn as_mut(&mut self) -> &mut Quat {
+        &mut self.0
+    }
+}
+
+pub trait SplineQuatExt {
+    fn slerp(self) -> Self;
+}
+
+impl SplineQuatExt for Spline<f32, Quat> {
+    fn slerp(self) -> Self {
+        let keys = self.keys();
+
+        if keys.len() < 2 {
+            return self;
+        }
+
+        let mut new_keys = Vec::with_capacity(keys.len());
+        for window in keys.windows(2) {
+            // TODO array_windows
+            let [a, b] = match *window {
+                [a, b] => [a, b],
+                _ => unreachable!(),
+            };
+
+            match a.interpolation {
+                Interpolation::Step(_) => new_keys.push(a),
+                Interpolation::Linear => {
+                    new_keys.push(a);
+
+                    const COS_MIN_ANGLE: f32 = 0.9995;
+                    let cos_angle = a.value.dot(b.value);
+                    if cos_angle < COS_MIN_ANGLE {
+                        let angle = cos_angle.acos();
+                        let min_angle = COS_MIN_ANGLE.acos();
+                        let steps = (angle / min_angle) as u32 + 1;
+
+                        let step_t = (b.t - a.t) / steps as f32;
+                        for i in 1..steps {
+                            let delta_t = (i as f32) * step_t;
+                            new_keys.push(Key {
+                                value: a.value.slerp(b.value, delta_t),
+                                t: delta_t + a.t,
+                                interpolation: Interpolation::Linear,
+                            });
+                        }
+                    }
+                }
+                _ => unimplemented!("Only Interpolation::Linear and Step are supported for now."),
+            }
+        }
+        new_keys.push(*keys.last().unwrap());
+
+        Spline::from_vec(new_keys)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn noop_resample() {
+        const MIN_ANGLE: f32 = 0.0316;
+        let spline = Spline::from_vec(vec![
+            Key {
+                t: 0.,
+                value: Quat::from_axis_angle(bevy_math::Vec3::unit_z(), 0.),
+                interpolation: Interpolation::Linear,
+            },
+            Key {
+                t: 1.,
+                value: Quat::from_axis_angle(bevy_math::Vec3::unit_z(), MIN_ANGLE),
+                interpolation: Interpolation::Linear,
+            },
+            Key {
+                t: 2.,
+                value: Quat::from_axis_angle(bevy_math::Vec3::unit_z(), 2. * MIN_ANGLE),
+                interpolation: Interpolation::Linear,
+            },
+        ]);
+
+        assert_eq!(spline.clone().keys(), spline.slerp().keys());
+    }
+
+    #[test]
+    fn big_resample() {
+        let spline = Spline::from_vec(vec![
+            Key {
+                t: 0.,
+                value: Quat::from_xyzw(0., 0., 0., 1.),
+                interpolation: Interpolation::Linear,
+            },
+            Key {
+                t: 1.,
+                value: Quat::from_xyzw(0., 0., 1., 0.),
+                interpolation: Interpolation::Linear,
+            },
+        ]);
+
+        let slerped = spline.clone().slerp();
+
+        assert_eq!(spline.start_time(), slerped.start_time());
+        assert_eq!(spline.end_time(), slerped.end_time());
+        assert!(spline.keys().len() < slerped.keys().len());
+    }
+}
+
+pub struct TransformSample {
+    pub translation: Vec3Option,
+    pub rotation: Option<Quat>,
+    pub scale: Option<f32>,
+}
+
+pub struct AnimationSplineTransform {
+    pub translation_x: Spline<f32, f32>,
+    pub translation_y: Spline<f32, f32>,
+    pub translation_z: Spline<f32, f32>,
+    pub rotation: Spline<f32, Quat>,
+    pub scale: Spline<f32, f32>,
+    pub loop_style: LoopStyle,
+    pub time: f32,
+    pub speed: f32,
+    pub paused: bool,
+    pub pong: bool,
+}
+
+impl Default for AnimationSplineTransform {
+    fn default() -> Self {
+        Self {
+            translation_x: Spline::from_vec(vec![]),
+            translation_y: Spline::from_vec(vec![]),
+            translation_z: Spline::from_vec(vec![]),
+            rotation: Spline::from_vec(vec![]),
+            scale: Spline::from_vec(vec![]),
+            loop_style: LoopStyle::Once,
+            time: 0.0,
+            speed: 1.0,
+            paused: false,
+            pong: false,
+        }
+    }
+}
+
+fn cmp_f32(a: &f32, b: &f32) -> std::cmp::Ordering {
+    a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)
+}
+
+impl SplineGroup for AnimationSplineTransform {
+    type Sample = TransformSample;
+
+    fn is_empty(&self) -> bool {
+        self.scale.is_empty()
+            && self.translation_x.is_empty()
+            && self.translation_y.is_empty()
+            && self.translation_z.is_empty()
+            && self.rotation.is_empty()
+    }
+
+    fn start_time(&self) -> Option<f32> {
+        self.scale
+            .start_time()
+            .into_iter()
+            .chain(self.translation_x.start_time())
+            .chain(self.translation_y.start_time())
+            .chain(self.translation_z.start_time())
+            .chain(self.rotation.start_time())
+            .min_by(cmp_f32)
+    }
+
+    fn end_time(&self) -> Option<f32> {
+        self.scale
+            .end_time()
+            .into_iter()
+            .chain(self.translation_x.end_time())
+            .chain(self.translation_y.end_time())
+            .chain(self.translation_z.end_time())
+            .chain(self.rotation.end_time())
+            .max_by(cmp_f32)
+    }
+
+    fn loop_style(&self) -> LoopStyle {
+        self.loop_style
+    }
+
+    fn loop_style_mut(&mut self) -> &mut LoopStyle {
+        &mut self.loop_style
+    }
+
+    fn time(&self) -> f32 {
+        self.time
+    }
+
+    fn time_mut(&mut self) -> &mut f32 {
+        &mut self.time
+    }
+
+    fn speed(&self) -> f32 {
+        self.speed
+    }
+
+    fn speed_mut(&mut self) -> &mut f32 {
+        &mut self.speed
+    }
+
+    fn paused(&self) -> bool {
+        self.paused
+    }
+
+    fn paused_mut(&mut self) -> &mut bool {
+        &mut self.paused
+    }
+
+    fn pong(&self) -> bool {
+        self.pong
+    }
+
+    fn pong_mut(&mut self) -> &mut bool {
+        &mut self.pong
+    }
+
+    fn sample(&self, time: f32) -> Self::Sample {
+        TransformSample {
+            translation: Vec3Option::new(
+                self.translation_x.sample(time),
+                self.translation_y.sample(time),
+                self.translation_z.sample(time),
+            ),
+            rotation: self.rotation.sample(time),
+            scale: self.scale.sample(time),
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/vec3_option.rs b/crates/bevy_animation/src/vec3_option.rs
new file mode 100644
index 0000000000000..c87ba21d32936
--- /dev/null
+++ b/crates/bevy_animation/src/vec3_option.rs
@@ -0,0 +1,82 @@
+use bevy_math::Vec3;
+use std::ops::Add;
+
+pub struct Vec3Option {
+    pub x: Option<f32>,
+    pub y: Option<f32>,
+    pub z: Option<f32>,
+}
+
+impl Vec3Option {
+    pub fn new(x: Option<f32>, y: Option<f32>, z: Option<f32>) -> Self {
+        Self { x, y, z }
+    }
+
+    pub fn alter(&self, vec: &mut Vec3) {
+        if let Some(x) = self.x {
+            vec.x = x;
+        }
+        if let Some(y) = self.y {
+            vec.y = y;
+        }
+        if let Some(z) = self.z {
+            vec.z = z;
+        }
+    }
+
+    pub fn zero() -> Self {
+        Self {
+            x: Some(0.0),
+            y: Some(0.0),
+            z: Some(0.0),
+        }
+    }
+
+    pub fn none() -> Self {
+        Self {
+            x: None,
+            y: None,
+            z: None,
+        }
+    }
+}
+
+fn add_one(l: Option<f32>, r: Option<f32>) -> Option<f32> {
+    if let (Some(l), Some(r)) = (l, r) {
+        Some(l + r)
+    } else {
+        l.or(r)
+    }
+}
+
+impl Add<Vec3Option> for Vec3Option {
+    type Output = Vec3Option;
+
+    fn add(self, other: Self) -> Self::Output {
+        Self {
+            x: add_one(self.x, other.x),
+            y: add_one(self.y, other.y),
+            z: add_one(self.z, other.z),
+        }
+    }
+}
+
+impl Add<Vec3Option> for Vec3 {
+    type Output = Vec3;
+
+    fn add(self, other: Vec3Option) -> Self::Output {
+        let mut res = Vec3::zero();
+        other.alter(&mut res);
+        self + res
+    }
+}
+
+impl Add<Vec3> for Vec3Option {
+    type Output = Vec3;
+
+    fn add(self, other: Vec3) -> Self::Output {
+        let mut res = Vec3::zero();
+        self.alter(&mut res);
+        res + other
+    }
+}
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 4475b06e80eff..5d7c19e4e6088 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -36,6 +36,7 @@ x11 = ["bevy_winit/x11"]
 
 [dependencies]
 # bevy
+bevy_animation = { path = "../bevy_animation", version = "0.3.0" }
 bevy_app = { path = "../bevy_app", version = "0.3.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
 bevy_core = { path = "../bevy_core", version = "0.3.0" }
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index e416c8b17ad7d..0f10118b9b539 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -13,6 +13,7 @@ impl PluginGroup for DefaultPlugins {
         group.add(bevy_window::WindowPlugin::default());
         group.add(bevy_asset::AssetPlugin::default());
         group.add(bevy_scene::ScenePlugin::default());
+        group.add(bevy_animation::AnimationPlugin::default());
 
         #[cfg(feature = "bevy_render")]
         group.add(bevy_render::RenderPlugin::default());
diff --git a/crates/bevy_internal/src/lib.rs b/crates/bevy_internal/src/lib.rs
index 4f2450bfa66d1..e204685c6ec3c 100644
--- a/crates/bevy_internal/src/lib.rs
+++ b/crates/bevy_internal/src/lib.rs
@@ -4,6 +4,10 @@ pub mod prelude;
 mod default_plugins;
 pub use default_plugins::*;
 
+pub mod animation {
+    pub use bevy_animation::*;
+}
+
 pub mod app {
     //! Build bevy apps, create plugins, and read events.
     pub use bevy_app::*;
diff --git a/crates/bevy_internal/src/prelude.rs b/crates/bevy_internal/src/prelude.rs
index 354ea005f293f..b3170c19820a6 100644
--- a/crates/bevy_internal/src/prelude.rs
+++ b/crates/bevy_internal/src/prelude.rs
@@ -1,6 +1,6 @@
 pub use crate::{
-    app::prelude::*, asset::prelude::*, core::prelude::*, ecs::prelude::*, input::prelude::*,
-    log::prelude::*, math::prelude::*, reflect::prelude::*, scene::prelude::*,
+    animation::prelude::*, app::prelude::*, asset::prelude::*, core::prelude::*, ecs::prelude::*,
+    input::prelude::*, log::prelude::*, math::prelude::*, reflect::prelude::*, scene::prelude::*,
     transform::prelude::*, window::prelude::*, DefaultPlugins, MinimalPlugins,
 };
 
diff --git a/examples/animation/animation_2d.rs b/examples/animation/animation_2d.rs
new file mode 100644
index 0000000000000..60b4f5366a97a
--- /dev/null
+++ b/examples/animation/animation_2d.rs
@@ -0,0 +1,67 @@
+use bevy::prelude::*;
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup)
+        .run();
+}
+
+fn setup(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let texture_handle = asset_server.load("branding/icon.png");
+
+    commands
+        .spawn(Camera2dBundle::default())
+        .spawn(SpriteBundle {
+            material: materials.add(texture_handle.into()),
+            ..Default::default()
+        })
+        .with(AnimationSplineTransform {
+            translation_x: Spline::from_vec(vec![
+                Key::new(0.0, 0.0, Interpolation::Cosine),
+                Key::new(1.0, -150.0, Interpolation::Cosine),
+                Key::new(2.0, 100.0, Interpolation::Cosine),
+                Key::new(3.0, 0.0, Interpolation::Cosine),
+            ]),
+            translation_y: Spline::from_vec(vec![
+                Key::new(0.0, 100.0, Interpolation::Linear),
+                Key::new(1.5, -100.0, Interpolation::Linear),
+                Key::new(3.0, 100.0, Interpolation::Linear),
+            ]),
+            translation_z: Spline::from_vec(vec![]),
+            rotation: Spline::from_vec(vec![
+                Key::new(
+                    0.0,
+                    Quat::from_rotation_ypr(0., 0., 720_f32.to_radians()),
+                    Interpolation::Linear,
+                ),
+                Key::new(
+                    1.0,
+                    Quat::from_rotation_ypr(0., 0., 480_f32.to_radians()),
+                    Interpolation::Linear,
+                ),
+                Key::new(
+                    2.0,
+                    Quat::from_rotation_ypr(0., 0., 240_f32.to_radians()),
+                    Interpolation::Linear,
+                ),
+                Key::new(
+                    3.0,
+                    Quat::from_rotation_ypr(0., 0., 0_f32.to_radians()),
+                    Interpolation::Linear,
+                ),
+            ])
+            .slerp(),
+            scale: Spline::from_vec(vec![
+                Key::new(0.0, 1.0, Interpolation::Cosine),
+                Key::new(0.5, 1.5, Interpolation::Cosine),
+                Key::new(1.0, 1.0, Interpolation::Cosine),
+            ]),
+            loop_style: LoopStyle::PingPong,
+            ..Default::default()
+        });
+}
diff --git a/examples/animation/animation_custom.rs b/examples/animation/animation_custom.rs
new file mode 100644
index 0000000000000..15657d84bb7ab
--- /dev/null
+++ b/examples/animation/animation_custom.rs
@@ -0,0 +1,55 @@
+use bevy::prelude::*;
+
+struct AnimatableFloat {
+    value: f32,
+}
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(update_text)
+        .add_system(animate_custom)
+        .run();
+}
+
+fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
+    let font: Handle<Font> = asset_server.load("fonts/FiraSans-Bold.ttf");
+    commands
+        .spawn(UiCameraBundle::default())
+        .spawn(TextBundle {
+            text: Text {
+                font,
+                value: "Unset".to_string(),
+                style: TextStyle {
+                    font_size: 30.0,
+                    color: Color::WHITE,
+                    ..Default::default()
+                },
+            },
+            ..Default::default()
+        })
+        .with(AnimatableFloat { value: 0.0 })
+        .with(AnimationSplineOne {
+            spline: Spline::from_vec(vec![
+                Key::new(0.0, 0.0, Interpolation::Cosine),
+                Key::new(3.0, 1000.0, Interpolation::Cosine),
+            ]),
+            loop_style: LoopStyle::PingPong,
+            ..Default::default()
+        });
+}
+
+fn update_text(mut q: Query<(&AnimatableFloat, &mut Text)>) {
+    for (float, mut text) in q.iter_mut() {
+        text.value = format!("{:.0}", float.value);
+    }
+}
+
+fn animate_custom(mut q: Query<(&AnimationSplineOne, &mut AnimatableFloat)>) {
+    for (animator, mut float) in q.iter_mut() {
+        if let Some(val) = animator.current() {
+            float.value = val;
+        }
+    }
+}