diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2c35fbc..7b8787c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,22 @@
 # Changelog
 
+## 0.14.0
+
+This version uses Bevy's **Required Components**,
+therefore many items have been changed.
+Examples may help migration.
+
+- `Path` component renamed to `Shape`. It is now the central component of a shape entity.
+- `Shape` now includes fill and stroke data.
+- `Fill` and `Stroke` are no longer `Component`s.
+- Deprecated `ShapeBundle` in favor of the `Shape` component.
+- `prelude` no longer exports `ShapeBundle`.
+- Added `ShapeBuilder`: works similarly to `GeometryBuilder`
+- Removed `GeometryBuilder` and `ShapePath`.
+- `PathBuilder` now allows chaining methods.
+
 ## 0.13.0
-- Support for Bevy 0.15.0-rc.3.
+- Support for Bevy 0.15.0.
 - `Rectangle` now supports border radii (see `rectangle.rs` example).
 - Removed deprecated `SpatialBundle` from `ShapeBundle`: `Transform` and `Visibility` are now added separately.
 
diff --git a/README.md b/README.md
index e496804..9c8a41e 100644
--- a/README.md
+++ b/README.md
@@ -44,14 +44,12 @@ fn setup_system(mut commands: Commands) {
     };
 
     commands.spawn((Camera2d, Msaa::Sample4));
-    commands.spawn((
-        ShapeBundle {
-            path: GeometryBuilder::build_as(&shape),
-            ..default()
-        },
-        Fill::color(DARK_CYAN),
-        Stroke::new(BLACK, 10.0),
-    ));
+    commands.spawn(
+        ShapeBuilder::with(&shape)
+            .fill(DARK_CYAN)
+            .stroke((BLACK, 10.0))
+            .build(),
+    );
 }
 ```
 
diff --git a/examples/dynamic_shape.rs b/examples/dynamic_shape.rs
index a272f62..f81bd04 100644
--- a/examples/dynamic_shape.rs
+++ b/examples/dynamic_shape.rs
@@ -7,8 +7,7 @@ fn main() {
     App::new()
         .add_plugins((DefaultPlugins, ShapePlugin))
         .add_systems(Startup, setup_system)
-        .add_systems(Update, change_draw_mode_system)
-        .add_systems(Update, change_number_of_sides)
+        .add_systems(Update, redraw_shape)
         .add_systems(Update, rotate_shape_system)
         .run();
 }
@@ -24,28 +23,22 @@ fn rotate_shape_system(mut query: Query<&mut Transform, With<ExampleShape>>, tim
     }
 }
 
-fn change_draw_mode_system(mut query: Query<(&mut Fill, &mut Stroke)>, time: Res<Time>) {
+fn redraw_shape(mut query: Query<&mut Shape, With<ExampleShape>>, time: Res<Time>) {
     let hue = (time.elapsed_secs_f64() * 50.0) % 360.0;
+    let color = Color::hsl(hue as f32, 1.0, 0.5);
     let outline_width = 2.0 + time.elapsed_secs_f64().sin().abs() * 10.0;
-
-    for (mut fill_mode, mut stroke_mode) in query.iter_mut() {
-        fill_mode.color = Color::hsl(hue as f32, 1.0, 0.5);
-        stroke_mode.options.line_width = outline_width as f32;
-    }
-}
-
-fn change_number_of_sides(mut query: Query<&mut Path>, time: Res<Time>) {
     let sides = ((time.elapsed_secs_f64() - PI * 2.5).sin() * 2.5 + 5.5).round() as usize;
+    let polygon = shapes::RegularPolygon {
+        sides,
+        feature: shapes::RegularPolygonFeature::Radius(200.0),
+        ..shapes::RegularPolygon::default()
+    };
 
-    for mut path in query.iter_mut() {
-        let polygon = shapes::RegularPolygon {
-            sides,
-            feature: shapes::RegularPolygonFeature::Radius(200.0),
-            ..shapes::RegularPolygon::default()
-        };
-
-        *path = ShapePath::build_as(&polygon);
-    }
+    let mut shape = query.single_mut();
+    *shape = ShapeBuilder::with(&polygon)
+        .fill(color)
+        .stroke((BLACK, outline_width as f32))
+        .build();
 }
 
 fn setup_system(mut commands: Commands) {
@@ -57,12 +50,10 @@ fn setup_system(mut commands: Commands) {
 
     commands.spawn((Camera2d, Msaa::Sample4));
     commands.spawn((
-        ShapeBundle {
-            path: GeometryBuilder::build_as(&shape),
-            ..default()
-        },
-        Fill::color(DARK_CYAN),
-        Stroke::new(BLACK, 10.0),
+        ShapeBuilder::with(&shape)
+            .fill(DARK_CYAN)
+            .stroke((BLACK, 10.0))
+            .build(),
         ExampleShape,
     ));
 }
diff --git a/examples/path.rs b/examples/path.rs
index 29143d1..62d9eaa 100644
--- a/examples/path.rs
+++ b/examples/path.rs
@@ -9,30 +9,23 @@ fn main() {
 }
 
 fn setup_system(mut commands: Commands) {
-    let mut path_builder = PathBuilder::new();
-    path_builder.move_to(Vec2::new(0., 0.));
-    path_builder.cubic_bezier_to(
-        Vec2::new(70., 70.),
-        Vec2::new(175., -35.),
-        Vec2::new(0., -140.),
-    );
-    path_builder.cubic_bezier_to(
-        Vec2::new(-175., -35.),
-        Vec2::new(-70., 70.),
-        Vec2::new(0., 0.),
-    );
-    path_builder.close();
-    let path = path_builder.build();
+    let shape = PathBuilder::new()
+        .fill(RED)
+        .stroke((BLACK, 10.0))
+        .move_to(Vec2::new(0., 0.))
+        .cubic_bezier_to(
+            Vec2::new(70., 70.),
+            Vec2::new(175., -35.),
+            Vec2::new(0., -140.),
+        )
+        .cubic_bezier_to(
+            Vec2::new(-175., -35.),
+            Vec2::new(-70., 70.),
+            Vec2::new(0., 0.),
+        )
+        .close()
+        .build();
 
     commands.spawn((Camera2d, Msaa::Sample4));
-    commands.spawn((
-        ShapeBundle {
-            path,
-            transform: Transform::from_xyz(0., 75., 0.),
-            visibility: default(),
-            ..default()
-        },
-        Stroke::new(BLACK, 10.0),
-        Fill::color(RED),
-    ));
+    commands.spawn((shape, Transform::from_xyz(0., 75., 0.)));
 }
diff --git a/examples/readme.rs b/examples/readme.rs
index 4c7b139..8c60454 100644
--- a/examples/readme.rs
+++ b/examples/readme.rs
@@ -19,12 +19,10 @@ fn setup_system(mut commands: Commands) {
     };
 
     commands.spawn((Camera2d, Msaa::Sample4));
-    commands.spawn((
-        ShapeBundle {
-            path: GeometryBuilder::build_as(&shape),
-            ..default()
-        },
-        Fill::color(DARK_CYAN),
-        Stroke::new(BLACK, 10.0),
-    ));
+    commands.spawn(
+        ShapeBuilder::with(&shape)
+            .fill(DARK_CYAN)
+            .stroke((BLACK, 10.0))
+            .build(),
+    );
 }
diff --git a/examples/rectangle.rs b/examples/rectangle.rs
index 932e5c2..f3dfcd4 100644
--- a/examples/rectangle.rs
+++ b/examples/rectangle.rs
@@ -16,12 +16,10 @@ fn setup_system(mut commands: Commands) {
     };
 
     commands.spawn((Camera2d, Msaa::Sample4));
-    commands.spawn((
-        ShapeBundle {
-            path: GeometryBuilder::build_as(&rect),
-            ..default()
-        },
-        Stroke::new(BLACK, 10.0),
-        Fill::color(RED),
-    ));
+    commands.spawn(
+        ShapeBuilder::with(&rect)
+            .stroke((BLACK, 10.0))
+            .fill(RED)
+            .build(),
+    );
 }
diff --git a/examples/rounded_polygon.rs b/examples/rounded_polygon.rs
index c48ebfe..00c9656 100644
--- a/examples/rounded_polygon.rs
+++ b/examples/rounded_polygon.rs
@@ -27,11 +27,5 @@ fn setup_system(mut commands: Commands) {
     };
 
     commands.spawn((Camera2d, Msaa::Sample4));
-    commands.spawn((
-        ShapeBundle {
-            path: GeometryBuilder::build_as(&shape),
-            ..default()
-        },
-        Fill::color(DARK_CYAN),
-    ));
+    commands.spawn(ShapeBuilder::with(&shape).fill(DARK_CYAN).build());
 }
diff --git a/examples/svg.rs b/examples/svg.rs
index 09d1539..1ffc335 100644
--- a/examples/svg.rs
+++ b/examples/svg.rs
@@ -30,26 +30,18 @@ fn setup_system(mut commands: Commands) {
         //the art style was approximated from https://www.kenney.nl/assets/cartography-pack
         .with_children(|parent| {
             let svg_doc_size = Vec2::new(512., 512.);
-            parent.spawn((
-                ShapeBundle {
-                    path: GeometryBuilder::build_as(&shapes::SvgPathShape {
-                        svg_path_string: BLACKSMITH_OUTLINE.to_owned(),
-                        svg_doc_size_in_px: svg_doc_size.to_owned(),
-                    }),
-                    ..default()
-                },
-                Stroke::new(Color::BLACK, 4.0),
-            ));
-            parent.spawn((
-                ShapeBundle {
-                    path: GeometryBuilder::build_as(&shapes::SvgPathShape {
-                        svg_path_string: BLACKSMITH_DETAIL.to_owned(),
-                        svg_doc_size_in_px: svg_doc_size.to_owned(),
-                    }),
-                    ..default()
-                },
-                Stroke::new(Color::BLACK, 2.5),
-            ));
+
+            let svg = shapes::SvgPathShape {
+                svg_path_string: BLACKSMITH_OUTLINE.to_owned(),
+                svg_doc_size_in_px: svg_doc_size.to_owned(),
+            };
+            parent.spawn(ShapeBuilder::with(&svg).stroke((Color::BLACK, 4.0)).build());
+
+            let svg = shapes::SvgPathShape {
+                svg_path_string: BLACKSMITH_DETAIL.to_owned(),
+                svg_doc_size_in_px: svg_doc_size.to_owned(),
+            };
+            parent.spawn(ShapeBuilder::with(&svg).stroke((Color::BLACK, 2.5)).build());
         });
 
     commands
@@ -69,28 +61,27 @@ fn setup_system(mut commands: Commands) {
         //the art style was approximated from https://www.kenney.nl/assets/cartography-pack
         .with_children(|parent| {
             let svg_doc_size = Vec2::new(1000., 1000.);
-            parent.spawn((
-                ShapeBundle {
-                    path: GeometryBuilder::build_as(&shapes::SvgPathShape {
-                        svg_path_string: SHACK.to_owned(),
-                        svg_doc_size_in_px: svg_doc_size.to_owned(),
-                    }),
-                    ..default()
-                },
-                Stroke::new(Color::BLACK, 20.0),
-            ));
+
+            let svg = shapes::SvgPathShape {
+                svg_path_string: SHACK.to_owned(),
+                svg_doc_size_in_px: svg_doc_size.to_owned(),
+            };
+            parent.spawn(
+                ShapeBuilder::with(&svg)
+                    .stroke((Color::BLACK, 20.0))
+                    .build(),
+            );
 
             // shack walls
-            parent.spawn((
-                ShapeBundle {
-                    path: GeometryBuilder::build_as(&shapes::SvgPathShape {
-                        svg_path_string: SHACK_WALLS.to_owned(),
-                        svg_doc_size_in_px: svg_doc_size.to_owned(),
-                    }),
-                    ..default()
-                },
-                Stroke::new(Color::BLACK, 17.5),
-            ));
+            let svg = shapes::SvgPathShape {
+                svg_path_string: SHACK_WALLS.to_owned(),
+                svg_doc_size_in_px: svg_doc_size.to_owned(),
+            };
+            parent.spawn(
+                ShapeBuilder::with(&svg)
+                    .stroke((Color::BLACK, 17.5))
+                    .build(),
+            );
         });
 }
 
diff --git a/src/draw.rs b/src/draw.rs
index 3b241fd..150116b 100644
--- a/src/draw.rs
+++ b/src/draw.rs
@@ -1,12 +1,12 @@
 //! Types for defining shape color and options.
 
-use bevy::{color::Color, ecs::component::Component};
+use bevy::color::{Color, Hsla, Hsva, Hwba, Laba, Lcha, LinearRgba, Oklaba, Oklcha, Srgba, Xyza};
 use lyon_tessellation::{FillOptions, StrokeOptions};
 
 /// Defines the fill options for the lyon tessellator and color of the generated
 /// vertices.
 #[allow(missing_docs)]
-#[derive(Component, Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Fill {
     pub options: FillOptions,
     pub color: Color,
@@ -23,10 +23,85 @@ impl Fill {
     }
 }
 
+impl Default for Fill {
+    fn default() -> Self {
+        Self {
+            options: FillOptions::default(),
+            color: bevy::color::palettes::css::WHITE.into(),
+        }
+    }
+}
+
+impl From<Color> for Fill {
+    fn from(color: Color) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Srgba> for Fill {
+    fn from(color: Srgba) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<LinearRgba> for Fill {
+    fn from(color: LinearRgba) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Hsla> for Fill {
+    fn from(color: Hsla) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Hsva> for Fill {
+    fn from(color: Hsva) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Hwba> for Fill {
+    fn from(color: Hwba) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Laba> for Fill {
+    fn from(color: Laba) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Lcha> for Fill {
+    fn from(color: Lcha) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Oklaba> for Fill {
+    fn from(color: Oklaba) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Oklcha> for Fill {
+    fn from(color: Oklcha) -> Self {
+        Self::color(color)
+    }
+}
+
+impl From<Xyza> for Fill {
+    fn from(color: Xyza) -> Self {
+        Self::color(color)
+    }
+}
+
 /// Defines the stroke options for the lyon tessellator and color of the
 /// generated vertices.
 #[allow(missing_docs)]
-#[derive(Component, Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Stroke {
     pub options: StrokeOptions,
     pub color: Color,
@@ -51,3 +126,78 @@ impl Stroke {
         }
     }
 }
+
+impl Default for Stroke {
+    fn default() -> Self {
+        Self {
+            options: StrokeOptions::default(),
+            color: bevy::color::palettes::css::BLACK.into(),
+        }
+    }
+}
+
+impl From<(Color, f32)> for Stroke {
+    fn from(value: (Color, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Srgba, f32)> for Stroke {
+    fn from(value: (Srgba, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(LinearRgba, f32)> for Stroke {
+    fn from(value: (LinearRgba, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Hsla, f32)> for Stroke {
+    fn from(value: (Hsla, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Hsva, f32)> for Stroke {
+    fn from(value: (Hsva, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Hwba, f32)> for Stroke {
+    fn from(value: (Hwba, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Laba, f32)> for Stroke {
+    fn from(value: (Laba, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Lcha, f32)> for Stroke {
+    fn from(value: (Lcha, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Oklaba, f32)> for Stroke {
+    fn from(value: (Oklaba, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Oklcha, f32)> for Stroke {
+    fn from(value: (Oklcha, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<(Xyza, f32)> for Stroke {
+    fn from(value: (Xyza, f32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
diff --git a/src/entity.rs b/src/entity.rs
index 182dcaa..ed17e7b 100644
--- a/src/entity.rs
+++ b/src/entity.rs
@@ -1,15 +1,21 @@
 //! Custom Bevy ECS bundle for shapes.
+#![expect(deprecated)]
 
 use bevy::prelude::*;
 use lyon_tessellation::{self as tess};
 
-use crate::{geometry::Geometry, plugin::COLOR_MATERIAL_HANDLE};
+use crate::{
+    draw::{Fill, Stroke},
+    geometry::Geometry,
+    plugin::COLOR_MATERIAL_HANDLE,
+};
 
 /// A Bevy `Bundle` to represent a shape.
+#[deprecated(since = "0.14.0", note = "please use the `Shape` component instead.")]
 #[allow(missing_docs)]
 #[derive(Bundle, Clone)]
 pub struct ShapeBundle {
-    pub path: Path,
+    pub path: Shape,
     pub mesh: Mesh2d,
     pub material: MeshMaterial2d<ColorMaterial>,
     pub transform: Transform,
@@ -28,12 +34,47 @@ impl Default for ShapeBundle {
     }
 }
 
-#[allow(missing_docs)]
+/// `Component` describing a geometric shape.
+///
+/// It can be constructed using `ShapeBuilder`.
 #[derive(Component, Default, Clone)]
-pub struct Path(pub tess::path::Path);
+#[require(Mesh2d, MeshMaterial2d<ColorMaterial>(color_material_handle), Transform, Visibility)]
+pub struct Shape {
+    path: tess::path::Path,
+    fill: Option<Fill>,
+    stroke: Option<Stroke>,
+}
+
+impl Shape {
+    pub(crate) fn new(path: tess::path::Path, fill: Option<Fill>, stroke: Option<Stroke>) -> Self {
+        Self { path, fill, stroke }
+    }
 
-impl Geometry for Path {
+    /// Returns the reference to the path of the shape.
+    #[allow(clippy::must_use_candidate)]
+    pub fn path_ref(&self) -> &tess::path::Path {
+        &self.path
+    }
+
+    /// Returns the fill options of the shape.
+    #[allow(clippy::must_use_candidate)]
+    pub fn fill(&self) -> Option<Fill> {
+        self.fill
+    }
+
+    /// Returns the stroke options of the shape.
+    #[allow(clippy::must_use_candidate)]
+    pub fn stroke(&self) -> Option<Stroke> {
+        self.stroke
+    }
+}
+
+impl Geometry for Shape {
     fn add_geometry(&self, b: &mut tess::path::path::Builder) {
-        b.extend_from_paths(&[self.0.as_slice()]);
+        b.extend_from_paths(&[self.path.as_slice()]);
     }
 }
+
+fn color_material_handle() -> MeshMaterial2d<ColorMaterial> {
+    MeshMaterial2d(COLOR_MATERIAL_HANDLE)
+}
diff --git a/src/geometry.rs b/src/geometry.rs
index 14a3e9f..c1a9c03 100644
--- a/src/geometry.rs
+++ b/src/geometry.rs
@@ -2,7 +2,10 @@
 
 use lyon_tessellation::path::path::Builder;
 
-use crate::entity::Path;
+use crate::{
+    draw::{Fill, Stroke},
+    entity::Shape,
+};
 
 /// Structs that implement this trait can be drawn as a shape. See the
 /// [`shapes`](crate::shapes) module for some examples.
@@ -49,86 +52,97 @@ pub trait Geometry {
     fn add_geometry(&self, b: &mut Builder);
 }
 
-/// Allows the creation of shapes using geometries added to a path builder.
-pub struct GeometryBuilder(Builder);
+/// Provides basic functionality common
+/// to [`ShapeBuilder`] and [`ReadyShapeBuilder`].
+pub trait ShapeBuilderBase {
+    /// Adds a `Geometry` to the builder.
+    #[must_use]
+    fn add(self, shape: &impl Geometry) -> Self;
 
-impl GeometryBuilder {
-    /// Creates a new, empty `GeometryBuilder`.
+    /// Sets the fill mode of the builder.
     #[must_use]
-    pub fn new() -> Self {
-        Self(Builder::new())
-    }
+    fn fill(self, fill: impl Into<Fill>) -> ReadyShapeBuilder;
 
-    /// Adds a geometry to the path builder.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use bevy_prototype_lyon::prelude::*;
-    /// # use bevy::color::palettes;
-    /// #
-    /// fn my_system(mut commands: Commands) {
-    ///     let line = shapes::Line(Vec2::ZERO, Vec2::new(10.0, 0.0));
-    ///     let square = shapes::Rectangle {
-    ///         extents: Vec2::splat(100.0),
-    ///         ..shapes::Rectangle::default()
-    ///     };
-    ///     let mut builder = GeometryBuilder::new().add(&line).add(&square);
-    ///
-    ///     commands.spawn((
-    ///         ShapeBundle {
-    ///             path: builder.build(),
-    ///             ..default()
-    ///         },
-    ///         Fill::color(Color::Srgba(palettes::css::ORANGE_RED)),
-    ///         Stroke::new(Color::Srgba(palettes::css::ORANGE_RED), 10.0),
-    ///     ));
-    /// }
-    /// # bevy::ecs::system::assert_is_system(my_system);
-    /// ```
-    #[allow(clippy::should_implement_trait)]
+    /// Sets the stroke mode of the builder.
     #[must_use]
-    pub fn add(mut self, shape: &impl Geometry) -> Self {
+    fn stroke(self, stroke: impl Into<Stroke>) -> ReadyShapeBuilder;
+}
+
+/// Provides methods for building a shape.
+#[derive(Default, Clone)]
+pub struct ShapeBuilder(Builder);
+
+impl ShapeBuilderBase for ShapeBuilder {
+    fn add(mut self, shape: &impl Geometry) -> Self {
         shape.add_geometry(&mut self.0);
         self
     }
 
-    /// Returns a [`Path`] using the data contained in the geometry
-    /// builder.
+    fn fill(self, fill: impl Into<Fill>) -> ReadyShapeBuilder {
+        ReadyShapeBuilder {
+            builder: self.0,
+            fill: Some(fill.into()),
+            stroke: None,
+        }
+    }
+
+    fn stroke(self, stroke: impl Into<Stroke>) -> ReadyShapeBuilder {
+        ReadyShapeBuilder {
+            builder: self.0,
+            fill: None,
+            stroke: Some(stroke.into()),
+        }
+    }
+}
+
+impl ShapeBuilder {
+    /// Constructs a new `ShapeBuilder`.
     #[must_use]
-    pub fn build(self) -> Path {
-        Path(self.0.build())
+    pub fn new() -> Self {
+        Self(Builder::new())
     }
 
-    /// Returns a [`Path`] component with only one geometry.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use bevy_prototype_lyon::prelude::*;
-    /// # use bevy::color::palettes;
-    /// #
-    /// fn my_system(mut commands: Commands) {
-    ///     let line = shapes::Line(Vec2::ZERO, Vec2::new(10.0, 0.0));
-    ///     commands.spawn((
-    ///         ShapeBundle {
-    ///             path: GeometryBuilder::build_as(&line),
-    ///             ..default()
-    ///         },
-    ///         Fill::color(Color::Srgba(palettes::css::ORANGE_RED)),
-    ///     ));
-    /// }
-    /// # bevy::ecs::system::assert_is_system(my_system);
-    /// ```
-    pub fn build_as(shape: &impl Geometry) -> Path {
-        Self::new().add(shape).build()
+    /// Constructs a new `ShapeBuilder` with an initial `Geometry`.
+    #[must_use]
+    pub fn with(geometry: &impl Geometry) -> Self {
+        Self::new().add(geometry)
     }
 }
 
-impl Default for GeometryBuilder {
-    fn default() -> Self {
-        Self::new()
+/// Provides methods for building a shape.
+///
+/// This struct can only be obtained by using [`ShapeBuilder`].
+#[derive(Clone)]
+pub struct ReadyShapeBuilder {
+    pub(crate) builder: Builder,
+    pub(crate) fill: Option<Fill>,
+    pub(crate) stroke: Option<Stroke>,
+}
+
+impl ShapeBuilderBase for ReadyShapeBuilder {
+    fn add(mut self, shape: &impl Geometry) -> Self {
+        shape.add_geometry(&mut self.builder);
+        self
+    }
+
+    fn fill(self, fill: impl Into<Fill>) -> ReadyShapeBuilder {
+        Self {
+            fill: Some(fill.into()),
+            ..self
+        }
+    }
+
+    fn stroke(self, stroke: impl Into<Stroke>) -> ReadyShapeBuilder {
+        Self {
+            stroke: Some(stroke.into()),
+            ..self
+        }
+    }
+}
+impl ReadyShapeBuilder {
+    /// Builds a `Shape` according to the builder's settings.
+    #[allow(clippy::must_use_candidate)]
+    pub fn build(self) -> Shape {
+        Shape::new(self.builder.build(), self.fill, self.stroke)
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index bbce4bb..989ce07 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -42,9 +42,9 @@ pub mod prelude {
 
     pub use crate::{
         draw::{Fill, Stroke},
-        entity::{Path, ShapeBundle},
-        geometry::{Geometry, GeometryBuilder},
-        path::{PathBuilder, ShapePath},
+        entity::Shape,
+        geometry::{Geometry, ShapeBuilder, ShapeBuilderBase},
+        path::PathBuilder,
         plugin::ShapePlugin,
         shapes::{self, BorderRadii, RectangleOrigin, RegularPolygon, RegularPolygonFeature},
     };
diff --git a/src/path.rs b/src/path.rs
index 011bd3b..904b43b 100644
--- a/src/path.rs
+++ b/src/path.rs
@@ -6,159 +6,111 @@ use lyon_tessellation::{
     path::{
         builder::WithSvg,
         path::{Builder, BuilderImpl},
-        EndpointId,
     },
 };
 
 use crate::{
-    entity::Path,
-    geometry::Geometry,
+    draw::{Fill, Stroke},
+    entity::Shape,
     utils::{ToPoint, ToVector},
 };
 
-/// A builder for `Path`s based on shapes implementing [`Geometry`].
-pub struct ShapePath(Builder);
+/// A SVG-like path builder.
+pub struct PathBuilder {
+    builder: WithSvg<BuilderImpl>,
+    fill: Option<Fill>,
+    stroke: Option<Stroke>,
+}
 
-impl ShapePath {
-    /// Returns a new builder.
+impl PathBuilder {
+    /// Returns a new, empty `PathBuilder`.
     #[must_use]
     pub fn new() -> Self {
-        Self(Builder::new())
+        Self {
+            builder: Builder::new().with_svg(),
+            fill: None,
+            stroke: None,
+        }
     }
 
-    /// Adds a shape to the builder.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use bevy_prototype_lyon::prelude::{RegularPolygon, *};
-    /// #
-    /// # #[derive(Component)]
-    /// # struct Player;
-    /// #
-    /// fn my_system(mut query: Query<&mut Path, With<Player>>) {
-    ///     let mut path = query.single_mut();
-    ///
-    ///     let square = shapes::Rectangle {
-    ///         extents: Vec2::splat(50.0),
-    ///         ..shapes::Rectangle::default()
-    ///     };
-    ///     let triangle = RegularPolygon {
-    ///         sides: 3,
-    ///         center: Vec2::new(100.0, 0.0),
-    ///         ..RegularPolygon::default()
-    ///     };
-    ///
-    ///     *path = ShapePath::new().add(&square).add(&triangle).build();
-    /// }
-    /// # bevy::ecs::system::assert_is_system(my_system);
-    /// ```
-    #[allow(clippy::should_implement_trait)]
+    /// Returns a finalized [`Shape`].
     #[must_use]
-    pub fn add(mut self, shape: &impl Geometry) -> Self {
-        shape.add_geometry(&mut self.0);
-        self
+    pub fn build(self) -> Shape {
+        Shape::new(self.builder.build(), self.fill, self.stroke)
     }
 
-    /// Builds the `Path` and returns it.
-    #[must_use]
-    pub fn build(self) -> Path {
-        Path(self.0.build())
-    }
-
-    /// Directly builds a `Path` from a `shape`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use bevy_prototype_lyon::prelude::{RegularPolygon, *};
-    /// #
-    /// # #[derive(Component)]
-    /// # struct Player;
-    /// #
-    /// fn my_system(mut query: Query<&mut Path, With<Player>>) {
-    ///     let mut path = query.single_mut();
-    ///
-    ///     let triangle = RegularPolygon {
-    ///         sides: 3,
-    ///         center: Vec2::new(100.0, 0.0),
-    ///         ..RegularPolygon::default()
-    ///     };
-    ///
-    ///     *path = ShapePath::build_as(&triangle);
-    /// }
-    /// # bevy::ecs::system::assert_is_system(my_system);
-    /// ```
-    pub fn build_as(shape: &impl Geometry) -> Path {
-        Self::new().add(shape).build()
-    }
-}
-
-impl Default for ShapePath {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// A SVG-like path builder.
-pub struct PathBuilder(WithSvg<BuilderImpl>);
-
-impl PathBuilder {
-    /// Returns a new, empty `PathBuilder`.
+    /// Sets the fill mode of the path.
     #[must_use]
-    pub fn new() -> Self {
-        Self(Builder::new().with_svg())
+    pub fn fill(self, fill: impl Into<Fill>) -> Self {
+        Self {
+            fill: Some(fill.into()),
+            ..self
+        }
     }
 
-    /// Returns a finalized [`Path`].
+    /// Sets the stroke mode of the path.
     #[must_use]
-    pub fn build(self) -> Path {
-        Path(self.0.build())
+    pub fn stroke(self, stroke: impl Into<Stroke>) -> Self {
+        Self {
+            stroke: Some(stroke.into()),
+            ..self
+        }
     }
 
     /// Moves the current point to the given position.
-    pub fn move_to(&mut self, to: Vec2) -> EndpointId {
-        self.0.move_to(to.to_point())
+    #[must_use]
+    pub fn move_to(mut self, to: Vec2) -> Self {
+        self.builder.move_to(to.to_point());
+        self
     }
 
     /// Adds to the path a line from the current position to the given one.
-    pub fn line_to(&mut self, to: Vec2) -> EndpointId {
-        self.0.line_to(to.to_point())
+    #[must_use]
+    pub fn line_to(mut self, to: Vec2) -> Self {
+        self.builder.line_to(to.to_point());
+        self
     }
 
     /// Closes the shape, adding to the path a line from the current position to
     /// the starting location.
-    pub fn close(&mut self) {
-        self.0.close();
+    #[must_use]
+    pub fn close(mut self) -> Self {
+        self.builder.close();
+        self
     }
 
     /// Adds a quadratic bezier to the path.
-    pub fn quadratic_bezier_to(&mut self, ctrl: Vec2, to: Vec2) -> EndpointId {
-        self.0.quadratic_bezier_to(ctrl.to_point(), to.to_point())
+    #[must_use]
+    pub fn quadratic_bezier_to(mut self, ctrl: Vec2, to: Vec2) -> Self {
+        self.builder
+            .quadratic_bezier_to(ctrl.to_point(), to.to_point());
+        self
     }
 
     /// Adds a cubic bezier to the path.
-    pub fn cubic_bezier_to(&mut self, ctrl1: Vec2, ctrl2: Vec2, to: Vec2) -> EndpointId {
-        self.0
-            .cubic_bezier_to(ctrl1.to_point(), ctrl2.to_point(), to.to_point())
+    #[must_use]
+    pub fn cubic_bezier_to(mut self, ctrl1: Vec2, ctrl2: Vec2, to: Vec2) -> Self {
+        self.builder
+            .cubic_bezier_to(ctrl1.to_point(), ctrl2.to_point(), to.to_point());
+        self
     }
 
     /// Adds an arc to the path.
-    pub fn arc(&mut self, center: Vec2, radii: Vec2, sweep_angle: f32, x_rotation: f32) {
-        self.0.arc(
+    #[must_use]
+    pub fn arc(mut self, center: Vec2, radii: Vec2, sweep_angle: f32, x_rotation: f32) -> Self {
+        self.builder.arc(
             center.to_point(),
             radii.to_vector(),
             Angle::radians(sweep_angle),
             Angle::radians(x_rotation),
         );
+        self
     }
 
     /// Returns the path's current position.
-    #[must_use]
+    #[allow(clippy::must_use_candidate)]
     pub fn current_position(&self) -> Vec2 {
-        let p = self.0.current_position();
+        let p = self.builder.current_position();
         Vec2::new(p.x, p.y)
     }
 }
diff --git a/src/plugin.rs b/src/plugin.rs
index 9c8a715..0ba9b33 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -2,17 +2,8 @@
 //!
 //! The [`ShapePlugin`] provides the creation of shapes with minimal
 //! boilerplate.
-//!
-//! ## How it works
-//! The user spawns a [`ShapeBundle`](crate::entity::ShapeBundle) from a
-//! system in the `UPDATE` stage.
-//!
-//! Then, in [`Stage::Shape`] stage, there is a system
-//! that creates a mesh for each entity that has been spawned as a
-//! `ShapeBundle`.
 
 use bevy::{
-    color::palettes,
     prelude::*,
     render::{mesh::Indices, render_asset::RenderAssetUsages, render_resource::PrimitiveTopology},
 };
@@ -20,7 +11,7 @@ use lyon_tessellation::{self as tess, BuffersBuilder};
 
 use crate::{
     draw::{Fill, Stroke},
-    entity::Path,
+    entity::Shape,
     vertex::{VertexBuffers, VertexConstructor},
 };
 
@@ -60,38 +51,29 @@ impl Plugin for ShapePlugin {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SystemSet)]
 pub struct BuildShapes;
 
-/// Queries all the [`ShapeBundle`]s to mesh them when they are added
+/// Queries all the [`Shape`]s and their related components
+/// to mesh them when they are added
 /// or re-mesh them when they are changed.
 #[allow(clippy::type_complexity)]
 fn mesh_shapes_system(
     mut meshes: ResMut<Assets<Mesh>>,
     mut fill_tess: ResMut<FillTessellator>,
     mut stroke_tess: ResMut<StrokeTessellator>,
-    mut query: Query<
-        (Option<&Fill>, Option<&Stroke>, &Path, &mut Mesh2d),
-        Or<(Changed<Path>, Changed<Fill>, Changed<Stroke>)>,
-    >,
+    mut query: Query<(&Shape, &mut Mesh2d), Changed<Shape>>,
 ) {
-    for (maybe_fill_mode, maybe_stroke_mode, path, mut mesh) in &mut query {
+    for (shape, mut mesh) in &mut query {
         let mut buffers = VertexBuffers::new();
-
-        if let Some(fill_mode) = maybe_fill_mode {
-            fill(&mut fill_tess, &path.0, fill_mode, &mut buffers);
+        if let Some(fill_mode) = shape.fill() {
+            fill(&mut fill_tess, shape.path_ref(), fill_mode, &mut buffers);
         }
-
-        if let Some(stroke_mode) = maybe_stroke_mode {
-            stroke(&mut stroke_tess, &path.0, stroke_mode, &mut buffers);
-        }
-
-        if (maybe_fill_mode, maybe_stroke_mode) == (None, None) {
-            fill(
-                &mut fill_tess,
-                &path.0,
-                &Fill::color(Color::Srgba(palettes::css::FUCHSIA)),
+        if let Some(stroke_mode) = shape.stroke() {
+            stroke(
+                &mut stroke_tess,
+                shape.path_ref(),
+                stroke_mode,
                 &mut buffers,
             );
         }
-
         mesh.0 = meshes.add(build_mesh(&buffers));
     }
 }
@@ -100,7 +82,7 @@ fn mesh_shapes_system(
 fn fill(
     tess: &mut ResMut<FillTessellator>,
     path: &tess::path::Path,
-    mode: &Fill,
+    mode: Fill,
     buffers: &mut VertexBuffers,
 ) {
     if let Err(e) = tess.tessellate_path(
@@ -116,7 +98,7 @@ fn fill(
 fn stroke(
     tess: &mut ResMut<StrokeTessellator>,
     path: &tess::path::Path,
-    mode: &Stroke,
+    mode: Stroke,
     buffers: &mut VertexBuffers,
 ) {
     if let Err(e) = tess.tessellate_path(