diff --git a/bezier-rs/docs/interactive-docs/src/App.vue b/bezier-rs/docs/interactive-docs/src/App.vue
index 03e7b22e..307d1803 100644
--- a/bezier-rs/docs/interactive-docs/src/App.vue
+++ b/bezier-rs/docs/interactive-docs/src/App.vue
@@ -114,9 +114,9 @@ export default defineComponent({
 					name: "Lookup Table",
 					callback: (canvas: HTMLCanvasElement, bezier: WasmBezierInstance, options: Record<string, number>): void => {
 						const lookupPoints = bezier.compute_lookup_table(options.steps);
-						lookupPoints.forEach((serialisedPoint, index) => {
+						lookupPoints.forEach((serializedPoint, index) => {
 							if (index !== 0 && index !== lookupPoints.length - 1) {
-								drawPoint(getContextFromCanvas(canvas), JSON.parse(serialisedPoint), 3, COLORS.NON_INTERACTIVE.STROKE_1);
+								drawPoint(getContextFromCanvas(canvas), JSON.parse(serializedPoint), 3, COLORS.NON_INTERACTIVE.STROKE_1);
 							}
 						});
 					},
@@ -339,9 +339,7 @@ export default defineComponent({
 
 <style>
 #app {
-	font-family: Avenir, Helvetica, Arial, sans-serif;
-	-webkit-font-smoothing: antialiased;
-	-moz-osx-font-smoothing: grayscale;
+	font-family: Arial, sans-serif;
 	text-align: center;
 	color: #2c3e50;
 	margin-top: 60px;
diff --git a/bezier-rs/lib/src/lib.rs b/bezier-rs/lib/src/lib.rs
index 1a17d9d1..71e88ace 100644
--- a/bezier-rs/lib/src/lib.rs
+++ b/bezier-rs/lib/src/lib.rs
@@ -632,11 +632,11 @@ impl Bezier {
 	}
 
 	/// Determine if it is possible to scale the given curve, using the following conditions:
-	/// 1. All the control points are located on a single side of the curve.
+	/// 1. All the handles are located on a single side of the curve.
 	/// 2. The on-curve point for `t = 0.5` must occur roughly in the center of the polygon defined by the curve's endpoint normals.
 	/// See [the offset section](https://pomax.github.io/bezierinfo/#offsetting) of Pomax's bezier curve primer for more details.
 	fn is_scalable(&self) -> bool {
-		// Verify all the control points are located on a single side of the curve.
+		// Verify all the handles are located on a single side of the curve.
 		if let BezierHandles::Cubic { handle_start, handle_end } = self.handles {
 			let angle_1 = (self.end - self.start).angle_between(handle_start - self.start);
 			let angle_2 = (self.end - self.start).angle_between(handle_end - self.start);
diff --git a/deny.toml b/deny.toml
index 832ee98d..2c2944bb 100644
--- a/deny.toml
+++ b/deny.toml
@@ -66,7 +66,7 @@ ignore = [
 [licenses]
 # The lint level for crates which do not have a detectable license
 unlicensed = "deny"
-# List of explictly allowed licenses
+# List of explicitly allowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses
 # [possible values: any SPDX 3.11 short identifier (+ optional exception)].
 allow = [
@@ -74,7 +74,7 @@ allow = [
     "Apache-2.0",
     #"Apache-2.0 WITH LLVM-exception",
 ]
-# List of explictly disallowed licenses
+# List of explicitly disallowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses
 # [possible values: any SPDX 3.11 short identifier (+ optional exception)].
 deny = [
diff --git a/editor/src/consts.rs b/editor/src/consts.rs
index 150b6f7d..6c5eef4b 100644
--- a/editor/src/consts.rs
+++ b/editor/src/consts.rs
@@ -45,7 +45,7 @@ pub const BOUNDS_SELECT_THRESHOLD: f64 = 10.;
 pub const BOUNDS_ROTATE_THRESHOLD: f64 = 20.;
 
 // Path tool
-pub const VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE: f64 = 5.;
+pub const MANIPULATOR_GROUP_MARKER_SIZE: f64 = 5.;
 pub const SELECTION_THRESHOLD: f64 = 10.;
 
 // Pen tool
diff --git a/editor/src/dialog/dialogs/about_dialog.rs b/editor/src/dialog/dialogs/about_dialog.rs
index aef39f25..e19a9ba0 100644
--- a/editor/src/dialog/dialogs/about_dialog.rs
+++ b/editor/src/dialog/dialogs/about_dialog.rs
@@ -2,7 +2,7 @@ use crate::layout::widgets::*;
 use crate::message_prelude::FrontendMessage;
 use crate::misc::build_metadata::{commit_info_localized, release_series};
 
-/// A dialog for displaying information on [`BuildMetadata`] viewable via *Help* > *About Graphite* in the menu bar.
+/// A dialog for displaying information on [BuildMetadata] viewable via *Help* > *About Graphite* in the menu bar.
 pub struct AboutGraphite {
 	pub localized_commit_date: String,
 }
diff --git a/editor/src/dialog/dialogs/export_dialog.rs b/editor/src/dialog/dialogs/export_dialog.rs
index 39ec9eb8..2aa8f6ce 100644
--- a/editor/src/dialog/dialogs/export_dialog.rs
+++ b/editor/src/dialog/dialogs/export_dialog.rs
@@ -7,7 +7,7 @@ use crate::message_prelude::*;
 
 use serde::{Deserialize, Serialize};
 
-/// A dialog to allow users to customise their file export.
+/// A dialog to allow users to customize their file export.
 #[derive(Debug, Clone, Default)]
 pub struct Export {
 	pub file_name: String,
diff --git a/editor/src/document/document_message.rs b/editor/src/document/document_message.rs
index e21c7d44..05e3a01d 100644
--- a/editor/src/document/document_message.rs
+++ b/editor/src/document/document_message.rs
@@ -53,9 +53,9 @@ pub enum DocumentMessage {
 		layer_path: Vec<LayerId>,
 	},
 	DeleteSelectedLayers,
-	DeleteSelectedVectorPoints,
+	DeleteSelectedManipulatorPoints,
 	DeselectAllLayers,
-	DeselectAllVectorPoints,
+	DeselectAllManipulatorPoints,
 	DirtyRenderDocument,
 	DirtyRenderDocumentInOutlineView,
 	DocumentHistoryBackward,
@@ -83,7 +83,7 @@ pub enum DocumentMessage {
 		insert_index: isize,
 		reverse_index: bool,
 	},
-	MoveSelectedVectorPoints {
+	MoveSelectedManipulatorPoints {
 		layer_path: Vec<LayerId>,
 		delta: (f64, f64),
 		absolute_position: (f64, f64),
diff --git a/editor/src/document/document_message_handler.rs b/editor/src/document/document_message_handler.rs
index 16bff422..7501ea4c 100644
--- a/editor/src/document/document_message_handler.rs
+++ b/editor/src/document/document_message_handler.rs
@@ -23,7 +23,7 @@ use graphene::layers::folder_layer::FolderLayer;
 use graphene::layers::layer_info::{LayerDataType, LayerDataTypeDiscriminant};
 use graphene::layers::style::{Fill, RenderData, ViewMode};
 use graphene::layers::text_layer::{Font, FontCache};
-use graphene::layers::vector::vector_shape::VectorShape;
+use graphene::layers::vector::subpath::Subpath;
 use graphene::{DocumentError, DocumentResponse, LayerId, Operation as DocumentOperation};
 
 use glam::{DAffine2, DVec2};
@@ -201,20 +201,20 @@ impl DocumentMessageHandler {
 		})
 	}
 
-	/// Returns a copy of all the currently selected VectorShapes.
-	pub fn selected_vector_shapes(&self) -> Vec<VectorShape> {
+	/// Returns a copy of all the currently selected [Subpath]s.
+	pub fn selected_subpaths(&self) -> Vec<Subpath> {
 		self.selected_visible_layers()
 			.flat_map(|layer| self.graphene_document.layer(layer))
-			.flat_map(|layer| layer.as_vector_shape_copy())
-			.collect::<Vec<VectorShape>>()
+			.flat_map(|layer| layer.as_subpath_copy())
+			.collect::<Vec<Subpath>>()
 	}
 
-	/// Returns references to all the currently selected VectorShapes.
-	pub fn selected_vector_shapes_ref(&self) -> Vec<&VectorShape> {
+	/// Returns references to all the currently selected [Subpath]s.
+	pub fn selected_subpaths_ref(&self) -> Vec<&Subpath> {
 		self.selected_visible_layers()
 			.flat_map(|layer| self.graphene_document.layer(layer))
-			.flat_map(|layer| layer.as_vector_shape())
-			.collect::<Vec<&VectorShape>>()
+			.flat_map(|layer| layer.as_subpath())
+			.collect::<Vec<&Subpath>>()
 	}
 
 	/// Returns the bounding boxes for all visible layers and artboards, optionally excluding any paths.
@@ -501,7 +501,7 @@ impl DocumentMessageHandler {
 	/// Calculate the path that new layers should be inserted to.
 	/// Depends on the selected layers as well as their types (Folder/Non-Folder)
 	pub fn get_path_for_new_layer(&self) -> Vec<u64> {
-		// If the selected layers dont actually exist, a new uuid for the
+		// If the selected layers don't actually exist, a new uuid for the
 		// root folder will be returned
 		let mut path = self.graphene_document.shallowest_common_folder(self.selected_layers()).map_or(vec![], |v| v.to_vec());
 		path.push(generate_uuid());
@@ -1016,11 +1016,11 @@ impl MessageHandler<DocumentMessage, (&InputPreprocessorMessageHandler, &FontCac
 				responses.push_front(BroadcastSignal::SelectionChanged.into());
 				responses.push_back(BroadcastSignal::DocumentIsDirty.into());
 			}
-			DeleteSelectedVectorPoints => {
+			DeleteSelectedManipulatorPoints => {
 				responses.push_back(StartTransaction.into());
 
 				responses.push_front(
-					DocumentOperation::DeleteSelectedVectorPoints {
+					DocumentOperation::DeleteSelectedManipulatorPoints {
 						layer_paths: self.selected_layers_without_children().iter().map(|path| path.to_vec()).collect(),
 					}
 					.into(),
@@ -1030,9 +1030,9 @@ impl MessageHandler<DocumentMessage, (&InputPreprocessorMessageHandler, &FontCac
 				responses.push_front(SetSelectedLayers { replacement_selected_layers: vec![] }.into());
 				self.layer_range_selection_reference.clear();
 			}
-			DeselectAllVectorPoints => {
+			DeselectAllManipulatorPoints => {
 				for layer_path in self.selected_layers_without_children() {
-					responses.push_back(DocumentOperation::DeselectAllVectorPoints { layer_path: layer_path.to_vec() }.into());
+					responses.push_back(DocumentOperation::DeselectAllManipulatorPoints { layer_path: layer_path.to_vec() }.into());
 				}
 			}
 			DirtyRenderDocument => {
@@ -1074,12 +1074,7 @@ impl MessageHandler<DocumentMessage, (&InputPreprocessorMessageHandler, &FontCac
 				let bbox = match bounds {
 					ExportBounds::AllArtwork => self.all_layer_bounds(font_cache),
 					ExportBounds::Selection => self.selected_visible_layers_bounding_box(font_cache),
-					ExportBounds::Artboard(id) => self
-						.artboard_message_handler
-						.artboards_graphene_document
-						.layer(&[id])
-						.ok()
-						.and_then(|layer| layer.aabounding_box(font_cache)),
+					ExportBounds::Artboard(id) => self.artboard_message_handler.artboards_graphene_document.layer(&[id]).ok().and_then(|layer| layer.aabb(font_cache)),
 				}
 				.unwrap_or_default();
 				let size = bbox[1] - bbox[0];
@@ -1195,10 +1190,10 @@ impl MessageHandler<DocumentMessage, (&InputPreprocessorMessageHandler, &FontCac
 					.into(),
 				);
 			}
-			MoveSelectedVectorPoints { layer_path, delta, absolute_position } => {
+			MoveSelectedManipulatorPoints { layer_path, delta, absolute_position } => {
 				self.backup(responses);
 				if let Ok(_layer) = self.graphene_document.layer(&layer_path) {
-					responses.push_back(DocumentOperation::MoveSelectedVectorPoints { layer_path, delta, absolute_position }.into());
+					responses.push_back(DocumentOperation::MoveSelectedManipulatorPoints { layer_path, delta, absolute_position }.into());
 				}
 			}
 			NudgeSelectedLayers { delta_x, delta_y } => {
diff --git a/editor/src/document/transformation.rs b/editor/src/document/transformation.rs
index 9134574e..029a1497 100644
--- a/editor/src/document/transformation.rs
+++ b/editor/src/document/transformation.rs
@@ -226,7 +226,7 @@ impl<'a> Selected<'a> {
 					.document
 					.layer(path)
 					.unwrap()
-					.aabounding_box_for_transform(multiplied_transform, font_cache)
+					.aabb_for_transform(multiplied_transform, font_cache)
 					.unwrap_or([multiplied_transform.translation; 2]);
 
 				(bounds[0] + bounds[1]) / 2.
diff --git a/editor/src/misc/build_metadata.rs b/editor/src/misc/build_metadata.rs
index 2a3c4a50..424ee886 100644
--- a/editor/src/misc/build_metadata.rs
+++ b/editor/src/misc/build_metadata.rs
@@ -1,6 +1,6 @@
-/// Provides metadata about the build environment.
-///
-/// This data is viewable in the editor via the [`crate::dialog::AboutGraphite`] dialog.
+//! Provides metadata about the build environment.
+//!
+//! This data is viewable in the editor via the [AboutGraphite](crate::dialog::AboutGraphite) dialog.
 
 pub fn release_series() -> String {
 	format!("Release Series: {}", env!("GRAPHITE_RELEASE_SERIES"))
diff --git a/editor/src/viewport_tools/snapping.rs b/editor/src/viewport_tools/snapping.rs
index 79527edd..ff80492a 100644
--- a/editor/src/viewport_tools/snapping.rs
+++ b/editor/src/viewport_tools/snapping.rs
@@ -7,7 +7,7 @@ use crate::message_prelude::*;
 
 use graphene::layers::layer_info::{Layer, LayerDataType};
 use graphene::layers::style::{self, Stroke};
-use graphene::layers::vector::constants::ControlPointType;
+use graphene::layers::vector::constants::ManipulatorType;
 use graphene::{LayerId, Operation};
 
 use glam::{DAffine2, DVec2};
@@ -246,25 +246,25 @@ impl SnapHandler {
 		}
 	}
 
-	/// Add the control points (optionally including bézier handles) of the specified shape layer to the snapping points
+	/// Add the [ManipulatorGroup]s (optionally including handles) of the specified shape layer to the snapping points
 	///
 	/// This should be called after start_snap
-	pub fn add_snap_path(&mut self, document_message_handler: &DocumentMessageHandler, layer: &Layer, path: &[LayerId], include_handles: bool, ignore_points: &[(&[LayerId], u64, ControlPointType)]) {
+	pub fn add_snap_path(&mut self, document_message_handler: &DocumentMessageHandler, layer: &Layer, path: &[LayerId], include_handles: bool, ignore_points: &[(&[LayerId], u64, ManipulatorType)]) {
 		if let LayerDataType::Shape(shape_layer) = &layer.data {
 			let transform = document_message_handler.graphene_document.multiply_transforms(path).unwrap();
 			let snap_points = shape_layer
 				.shape
-				.anchors()
+				.manipulator_groups()
 				.enumerate()
 				.flat_map(|(id, shape)| {
 					if include_handles {
 						[
-							(*id, &shape.points[ControlPointType::Anchor]),
-							(*id, &shape.points[ControlPointType::InHandle]),
-							(*id, &shape.points[ControlPointType::OutHandle]),
+							(*id, &shape.points[ManipulatorType::Anchor]),
+							(*id, &shape.points[ManipulatorType::InHandle]),
+							(*id, &shape.points[ManipulatorType::OutHandle]),
 						]
 					} else {
-						[(*id, &shape.points[ControlPointType::Anchor]), (0, &None), (0, &None)]
+						[(*id, &shape.points[ManipulatorType::Anchor]), (0, &None), (0, &None)]
 					}
 				})
 				.filter_map(|(id, point)| point.as_ref().map(|val| (id, val)))
@@ -281,7 +281,7 @@ impl SnapHandler {
 		document_message_handler: &DocumentMessageHandler,
 		include_handles: &[&[LayerId]],
 		exclude: &[&[LayerId]],
-		ignore_points: &[(&[LayerId], u64, ControlPointType)],
+		ignore_points: &[(&[LayerId], u64, ManipulatorType)],
 	) {
 		for path in document_message_handler.all_layers() {
 			if !exclude.contains(&path) {
diff --git a/editor/src/viewport_tools/tools/gradient_tool.rs b/editor/src/viewport_tools/tools/gradient_tool.rs
index 905b9e1c..9521602f 100644
--- a/editor/src/viewport_tools/tools/gradient_tool.rs
+++ b/editor/src/viewport_tools/tools/gradient_tool.rs
@@ -1,4 +1,4 @@
-use crate::consts::{COLOR_ACCENT, LINE_ROTATE_SNAP_ANGLE, SELECTION_TOLERANCE, VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE};
+use crate::consts::{COLOR_ACCENT, LINE_ROTATE_SNAP_ANGLE, MANIPULATOR_GROUP_MARKER_SIZE, SELECTION_TOLERANCE};
 use crate::document::DocumentMessageHandler;
 use crate::frontend::utility_types::MouseCursorIcon;
 use crate::input::keyboard::{Key, MouseMotion};
@@ -141,7 +141,7 @@ impl Default for GradientToolFsmState {
 
 /// Computes the transform from gradient space to layer space (where gradient space is 0..1 in layer space)
 fn gradient_space_transform(path: &[LayerId], layer: &Layer, document: &DocumentMessageHandler, font_cache: &FontCache) -> DAffine2 {
-	let bounds = layer.aabounding_box_for_transform(DAffine2::IDENTITY, font_cache).unwrap();
+	let bounds = layer.aabb_for_transform(DAffine2::IDENTITY, font_cache).unwrap();
 	let bound_transform = DAffine2::from_scale_angle_translation(bounds[1] - bounds[0], 0., bounds[0]);
 
 	let multiplied = document.graphene_document.multiply_transforms(path).unwrap();
@@ -163,7 +163,7 @@ impl GradientOverlay {
 	fn generate_overlay_handle(translation: DVec2, responses: &mut VecDeque<Message>, selected: bool) -> Vec<LayerId> {
 		let path = vec![generate_uuid()];
 
-		let size = DVec2::splat(VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE);
+		let size = DVec2::splat(MANIPULATOR_GROUP_MARKER_SIZE);
 
 		let fill = if selected { Fill::solid(COLOR_ACCENT) } else { Fill::solid(Color::WHITE) };
 
@@ -359,7 +359,7 @@ impl Fsm for GradientToolFsmState {
 					responses.push_back(BroadcastSignal::DocumentIsDirty.into());
 
 					let mouse = input.mouse.position;
-					let tolerance = VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE.powi(2);
+					let tolerance = MANIPULATOR_GROUP_MARKER_SIZE.powi(2);
 
 					let mut dragging = false;
 					for overlay in &tool_data.gradient_overlays {
diff --git a/editor/src/viewport_tools/tools/path_tool.rs b/editor/src/viewport_tools/tools/path_tool.rs
index 97aad268..cc3259da 100644
--- a/editor/src/viewport_tools/tools/path_tool.rs
+++ b/editor/src/viewport_tools/tools/path_tool.rs
@@ -10,7 +10,7 @@ use crate::viewport_tools::vector_editor::overlay_renderer::OverlayRenderer;
 use crate::viewport_tools::vector_editor::shape_editor::ShapeEditor;
 
 use graphene::intersection::Quad;
-use graphene::layers::vector::constants::ControlPointType;
+use graphene::layers::vector::constants::ManipulatorType;
 
 use glam::DVec2;
 use serde::{Deserialize, Serialize};
@@ -152,7 +152,7 @@ impl Fsm for PathToolFsmState {
 					tool_data.shape_editor.set_selected_layers(layer_paths);
 					// Render the new overlays
 					for layer_path in tool_data.shape_editor.selected_layers() {
-						tool_data.overlay_renderer.render_vector_shape_overlays(&document.graphene_document, layer_path.to_vec(), responses);
+						tool_data.overlay_renderer.render_subpath_overlays(&document.graphene_document, layer_path.to_vec(), responses);
 					}
 
 					// This can happen in any state (which is why we return self)
@@ -162,7 +162,7 @@ impl Fsm for PathToolFsmState {
 					// When the document has moved / needs to be redraw, re-render the overlays
 					// TODO the overlay system should probably receive this message instead of the tool
 					for layer_path in document.selected_visible_layers() {
-						tool_data.overlay_renderer.render_vector_shape_overlays(&document.graphene_document, layer_path.to_vec(), responses);
+						tool_data.overlay_renderer.render_subpath_overlays(&document.graphene_document, layer_path.to_vec(), responses);
 					}
 
 					self
@@ -186,9 +186,9 @@ impl Fsm for PathToolFsmState {
 						// Do not snap against handles when anchor is selected
 						let mut extension = Vec::new();
 						for &(path, id, point_type) in new_selected.iter() {
-							if point_type == ControlPointType::Anchor {
-								extension.push((path, id, ControlPointType::InHandle));
-								extension.push((path, id, ControlPointType::OutHandle));
+							if point_type == ManipulatorType::Anchor {
+								extension.push((path, id, ManipulatorType::InHandle));
+								extension.push((path, id, ManipulatorType::OutHandle));
 							}
 						}
 						new_selected.extend(extension);
@@ -269,14 +269,14 @@ impl Fsm for PathToolFsmState {
 					tool_data.shape_editor.delete_selected_points(responses);
 					responses.push_back(SelectionChanged.into());
 					for layer_path in document.all_layers() {
-						tool_data.overlay_renderer.clear_vector_shape_overlays(&document.graphene_document, layer_path.to_vec(), responses);
+						tool_data.overlay_renderer.clear_subpath_overlays(&document.graphene_document, layer_path.to_vec(), responses);
 					}
 					Ready
 				}
 				(_, Abort) => {
 					// TODO Tell overlay manager to remove the overlays
 					for layer_path in document.all_layers() {
-						tool_data.overlay_renderer.clear_vector_shape_overlays(&document.graphene_document, layer_path.to_vec(), responses);
+						tool_data.overlay_renderer.clear_subpath_overlays(&document.graphene_document, layer_path.to_vec(), responses);
 					}
 					Ready
 				}
diff --git a/editor/src/viewport_tools/tools/pen_tool.rs b/editor/src/viewport_tools/tools/pen_tool.rs
index fe4b99db..e833144e 100644
--- a/editor/src/viewport_tools/tools/pen_tool.rs
+++ b/editor/src/viewport_tools/tools/pen_tool.rs
@@ -11,9 +11,9 @@ use crate::viewport_tools::tool::{Fsm, SignalToMessageMap, ToolActionHandlerData
 use crate::viewport_tools::vector_editor::overlay_renderer::OverlayRenderer;
 
 use graphene::layers::style;
-use graphene::layers::vector::constants::ControlPointType;
-use graphene::layers::vector::vector_anchor::VectorAnchor;
-use graphene::layers::vector::vector_shape::VectorShape;
+use graphene::layers::vector::constants::ManipulatorType;
+use graphene::layers::vector::manipulator_group::ManipulatorGroup;
+use graphene::layers::vector::subpath::Subpath;
 use graphene::Operation;
 
 use glam::{DAffine2, DVec2};
@@ -180,7 +180,7 @@ impl Fsm for PenToolFsmState {
 					// When the document has moved / needs to be redraw, re-render the overlays
 					// TODO the overlay system should probably receive this message instead of the tool
 					for layer_path in document.selected_visible_layers() {
-						tool_data.overlay_renderer.render_vector_shape_overlays(&document.graphene_document, layer_path.to_vec(), responses);
+						tool_data.overlay_renderer.render_subpath_overlays(&document.graphene_document, layer_path.to_vec(), responses);
 					}
 					self
 				}
@@ -217,12 +217,15 @@ impl Fsm for PenToolFsmState {
 								path: layer_path.clone(),
 								transform: DAffine2::IDENTITY.to_cols_array(),
 								insert_index: -1,
-								vector_path: Default::default(),
+								subpath: Default::default(),
 								style: style::PathStyle::new(Some(style::Stroke::new(global_tool_data.primary_color, tool_data.weight)), style::Fill::None),
 							}
 							.into(),
 						);
-						responses.push_back(add_anchor(&tool_data.path, VectorAnchor::new_with_handles(start_position, Some(start_position), Some(start_position))));
+						responses.push_back(add_manipulator_group(
+							&tool_data.path,
+							ManipulatorGroup::new_with_handles(start_position, Some(start_position), Some(start_position)),
+						));
 					}
 
 					PenToolFsmState::DraggingHandle
@@ -231,9 +234,9 @@ impl Fsm for PenToolFsmState {
 				(PenToolFsmState::DraggingHandle, PenToolMessage::DragStop) => {
 					// Add new point onto path
 					if let Some(layer_path) = &tool_data.path {
-						if let Some(vector_anchor) = get_vector_shape(layer_path, document).and_then(|shape| shape.anchors().last()) {
-							if let Some(anchor) = &vector_anchor.points[ControlPointType::OutHandle] {
-								responses.push_back(add_anchor(&tool_data.path, VectorAnchor::new(anchor.position)));
+						if let Some(manipulator_group) = get_subpath(layer_path, document).and_then(|subpath| subpath.manipulator_groups().last()) {
+							if let Some(out_handle) = &manipulator_group.points[ManipulatorType::OutHandle] {
+								responses.push_back(add_manipulator_group(&tool_data.path, ManipulatorGroup::new_with_anchor(out_handle.position)));
 							}
 						}
 					}
@@ -244,29 +247,29 @@ impl Fsm for PenToolFsmState {
 					if let Some(layer_path) = &tool_data.path {
 						let mouse = tool_data.snap_handler.snap_position(responses, document, input.mouse.position);
 						let mut pos = transform.inverse().transform_point2(mouse);
-						if let Some(((&id, anchor), _previous)) = get_vector_shape(layer_path, document).and_then(last_2_anchors) {
-							if let Some(anchor) = anchor.points[ControlPointType::Anchor as usize].as_ref() {
+						if let Some(((&id, manipulator_group), _previous)) = get_subpath(layer_path, document).and_then(last_2_manipulator_groups) {
+							if let Some(anchor) = manipulator_group.points[ManipulatorType::Anchor].as_ref() {
 								pos = compute_snapped_angle(input, snap_angle, pos, anchor.position);
 							}
 
 							// Update points on current segment (to show preview of new handle)
-							let msg = Operation::MoveVectorPoint {
+							let msg = Operation::MoveManipulatorPoint {
 								layer_path: layer_path.clone(),
 								id,
-								control_type: ControlPointType::OutHandle,
+								manipulator_type: ManipulatorType::OutHandle,
 								position: pos.into(),
 							};
 							responses.push_back(msg.into());
 
-							// Mirror handle of last segement
-							if !input.keyboard.get(break_handle as usize) && get_vector_shape(layer_path, document).map(|shape| shape.anchors().len() > 1).unwrap_or_default() {
-								if let Some(anchor) = anchor.points[ControlPointType::Anchor as usize].as_ref() {
+							// Mirror handle of last segment
+							if !input.keyboard.get(break_handle as usize) && get_subpath(layer_path, document).map(|shape| shape.manipulator_groups().len() > 1).unwrap_or_default() {
+								if let Some(anchor) = manipulator_group.points[ManipulatorType::Anchor].as_ref() {
 									pos = anchor.position - (pos - anchor.position);
 								}
-								let msg = Operation::MoveVectorPoint {
+								let msg = Operation::MoveManipulatorPoint {
 									layer_path: layer_path.clone(),
 									id,
-									control_type: ControlPointType::InHandle,
+									manipulator_type: ManipulatorType::InHandle,
 									position: pos.into(),
 								};
 								responses.push_back(msg.into());
@@ -281,16 +284,16 @@ impl Fsm for PenToolFsmState {
 						let mouse = tool_data.snap_handler.snap_position(responses, document, input.mouse.position);
 						let mut pos = transform.inverse().transform_point2(mouse);
 
-						if let Some(((&id, _anchor), previous)) = get_vector_shape(layer_path, document).and_then(last_2_anchors) {
-							if let Some(relative) = previous.as_ref().and_then(|(_, anchor)| anchor.points[ControlPointType::Anchor as usize].as_ref()) {
+						if let Some(((&id, _), previous)) = get_subpath(layer_path, document).and_then(last_2_manipulator_groups) {
+							if let Some(relative) = previous.as_ref().and_then(|(_, manipulator_group)| manipulator_group.points[ManipulatorType::Anchor].as_ref()) {
 								pos = compute_snapped_angle(input, snap_angle, pos, relative.position);
 							}
 
-							for control_type in [ControlPointType::Anchor, ControlPointType::InHandle, ControlPointType::OutHandle] {
-								let msg = Operation::MoveVectorPoint {
+							for manipulator_type in [ManipulatorType::Anchor, ManipulatorType::InHandle, ManipulatorType::OutHandle] {
+								let msg = Operation::MoveManipulatorPoint {
 									layer_path: layer_path.clone(),
 									id,
-									control_type,
+									manipulator_type,
 									position: pos.into(),
 								};
 								responses.push_back(msg.into());
@@ -303,25 +306,25 @@ impl Fsm for PenToolFsmState {
 				(PenToolFsmState::DraggingHandle | PenToolFsmState::PlacingAnchor, PenToolMessage::Abort | PenToolMessage::Confirm) => {
 					// Abort or commit the transaction to the undo history
 					if let Some(layer_path) = tool_data.path.as_ref() {
-						if let Some(vector_shape) = (get_vector_shape(layer_path, document)).filter(|vector_shape| vector_shape.anchors().len() > 1) {
-							if let Some(((&(mut id), mut anchor), previous)) = last_2_anchors(vector_shape) {
+						if let Some(subpath) = (get_subpath(layer_path, document)).filter(|subpath| subpath.manipulator_groups().len() > 1) {
+							if let Some(((&(mut id), mut manipulator_group), previous)) = last_2_manipulator_groups(subpath) {
 								// Remove the unplaced anchor if in anchor placing mode
 								if self == PenToolFsmState::PlacingAnchor {
 									let layer_path = layer_path.clone();
-									let op = Operation::RemoveVectorAnchor { layer_path, id };
+									let op = Operation::RemoveManipulatorGroup { layer_path, id };
 									responses.push_back(op.into());
-									if let Some((&new_id, new_anchor)) = previous {
+									if let Some((&new_id, new_manipulator_group)) = previous {
 										id = new_id;
-										anchor = new_anchor;
+										manipulator_group = new_manipulator_group;
 									}
 								}
 
 								// Remove the out handle if in dragging handle mode
-								let op = Operation::MoveVectorPoint {
+								let op = Operation::MoveManipulatorPoint {
 									layer_path: layer_path.clone(),
 									id,
-									control_type: ControlPointType::OutHandle,
-									position: anchor.points[ControlPointType::Anchor as usize].as_ref().unwrap().position.into(),
+									manipulator_type: ManipulatorType::OutHandle,
+									position: manipulator_group.points[ManipulatorType::Anchor].as_ref().unwrap().position.into(),
 								};
 								responses.push_back(op.into());
 							}
@@ -334,7 +337,7 @@ impl Fsm for PenToolFsmState {
 
 					// Clean up overlays
 					for layer_path in document.all_layers() {
-						tool_data.overlay_renderer.clear_vector_shape_overlays(&document.graphene_document, layer_path.to_vec(), responses);
+						tool_data.overlay_renderer.clear_subpath_overlays(&document.graphene_document, layer_path.to_vec(), responses);
 					}
 					tool_data.path = None;
 					tool_data.snap_handler.cleanup(responses);
@@ -344,7 +347,7 @@ impl Fsm for PenToolFsmState {
 				(_, PenToolMessage::Abort) => {
 					// Clean up overlays
 					for layer_path in document.all_layers() {
-						tool_data.overlay_renderer.clear_vector_shape_overlays(&document.graphene_document, layer_path.to_vec(), responses);
+						tool_data.overlay_renderer.clear_subpath_overlays(&document.graphene_document, layer_path.to_vec(), responses);
 					}
 					self
 				}
@@ -373,7 +376,7 @@ impl Fsm for PenToolFsmState {
 				HintGroup(vec![HintInfo {
 					key_groups: vec![],
 					mouse: Some(MouseMotion::Lmb),
-					label: String::from("Add Control Point"),
+					label: String::from("Add Anchor"),
 					plus: false,
 				}]),
 				HintGroup(vec![HintInfo {
@@ -406,7 +409,7 @@ impl Fsm for PenToolFsmState {
 }
 
 // TODO: Expand `pos` name below to the full word (position?)
-/// Snap the angle of the line from relative to pos if the key is pressed
+/// Snap the angle of the line from relative to pos if the key is pressed.
 fn compute_snapped_angle(input: &InputPreprocessorMessageHandler, key: Key, pos: DVec2, relative: DVec2) -> DVec2 {
 	if input.keyboard.get(key as usize) {
 		let delta = relative - pos;
@@ -424,12 +427,12 @@ fn compute_snapped_angle(input: &InputPreprocessorMessageHandler, key: Key, pos:
 	}
 }
 
-/// Pushes an anchor to the current layer via an [Operation]
-fn add_anchor(layer_path: &Option<Vec<LayerId>>, anchor: VectorAnchor) -> Message {
+/// Pushes a [ManipulatorGroup] to the current layer via an [Operation].
+fn add_manipulator_group(layer_path: &Option<Vec<LayerId>>, manipulator_group: ManipulatorGroup) -> Message {
 	if let Some(layer_path) = layer_path {
-		Operation::PushVectorAnchor {
+		Operation::PushManipulatorGroup {
 			layer_path: layer_path.clone(),
-			anchor,
+			manipulator_group,
 		}
 		.into()
 	} else {
@@ -437,20 +440,20 @@ fn add_anchor(layer_path: &Option<Vec<LayerId>>, anchor: VectorAnchor) -> Messag
 	}
 }
 
-/// Gets the currently editing [VectorShape]
-fn get_vector_shape<'a>(layer_path: &'a [LayerId], document: &'a DocumentMessageHandler) -> Option<&'a VectorShape> {
-	document.graphene_document.layer(layer_path).ok().and_then(|layer| layer.as_vector_shape())
+/// Gets the currently editing [Subpath].
+fn get_subpath<'a>(layer_path: &'a [LayerId], document: &'a DocumentMessageHandler) -> Option<&'a Subpath> {
+	document.graphene_document.layer(layer_path).ok().and_then(|layer| layer.as_subpath())
 }
 
-type AnchorRef<'a> = (&'a u64, &'a VectorAnchor);
+type ManipulatorGroupRef<'a> = (&'a u64, &'a ManipulatorGroup);
 
-/// Gets the last 2 [VectorAnchor] on the currently editing layer along with its id
-fn last_2_anchors(vector_shape: &VectorShape) -> Option<(AnchorRef, Option<AnchorRef>)> {
-	vector_shape.anchors().enumerate().last().map(|last| {
+/// Gets the last 2 [ManipulatorGroup]s on the currently editing layer along with its ID.
+fn last_2_manipulator_groups(subpath: &Subpath) -> Option<(ManipulatorGroupRef, Option<ManipulatorGroupRef>)> {
+	subpath.manipulator_groups().enumerate().last().map(|last| {
 		(
 			last,
-			(vector_shape.anchors().len() > 1)
-				.then(|| vector_shape.anchors().enumerate().nth(vector_shape.anchors().len() - 2))
+			(subpath.manipulator_groups().len() > 1)
+				.then(|| subpath.manipulator_groups().enumerate().nth(subpath.manipulator_groups().len() - 2))
 				.flatten(),
 		)
 	})
diff --git a/editor/src/viewport_tools/tools/shared/path_outline.rs b/editor/src/viewport_tools/tools/shared/path_outline.rs
index a59e82b1..95e7eba6 100644
--- a/editor/src/viewport_tools/tools/shared/path_outline.rs
+++ b/editor/src/viewport_tools/tools/shared/path_outline.rs
@@ -7,7 +7,7 @@ use graphene::intersection::Quad;
 use graphene::layers::layer_info::LayerDataType;
 use graphene::layers::style::{self, Fill, Stroke};
 use graphene::layers::text_layer::FontCache;
-use graphene::layers::vector::vector_shape::VectorShape;
+use graphene::layers::vector::subpath::Subpath;
 use graphene::{LayerId, Operation};
 
 use glam::{DAffine2, DVec2};
@@ -35,12 +35,10 @@ impl PathOutline {
 
 		// TODO Purge this area of BezPath and Kurbo
 		// Get the bezpath from the shape or text
-		let vector_path = match &document_layer.data {
+		let subpath = match &document_layer.data {
 			LayerDataType::Shape(layer_shape) => Some(layer_shape.shape.clone()),
-			LayerDataType::Text(text) => Some(text.to_vector_path_nonmut(font_cache)),
-			_ => document_layer
-				.aabounding_box_for_transform(DAffine2::IDENTITY, font_cache)
-				.map(|[p1, p2]| VectorShape::new_rect(p1, p2)),
+			LayerDataType::Text(text) => Some(text.to_subpath_nonmut(font_cache)),
+			_ => document_layer.aabb_for_transform(DAffine2::IDENTITY, font_cache).map(|[p1, p2]| Subpath::new_rect(p1, p2)),
 		}?;
 
 		// Generate a new overlay layer if necessary
@@ -50,7 +48,7 @@ impl PathOutline {
 				let overlay_path = vec![generate_uuid()];
 				let operation = Operation::AddShape {
 					path: overlay_path.clone(),
-					vector_path: Default::default(),
+					subpath: Default::default(),
 					style: style::PathStyle::new(Some(Stroke::new(COLOR_ACCENT, PATH_OUTLINE_WEIGHT)), Fill::None),
 					insert_index: -1,
 					transform: DAffine2::IDENTITY.to_cols_array(),
@@ -63,7 +61,7 @@ impl PathOutline {
 		};
 
 		// Update the shape bezpath
-		let operation = Operation::SetShapePath { path: overlay.clone(), vector_path };
+		let operation = Operation::SetShapePath { path: overlay.clone(), subpath };
 		responses.push_back(DocumentMessage::Overlays(operation.into()).into());
 
 		// Update the transform to match the document
@@ -110,7 +108,7 @@ impl PathOutline {
 		}
 	}
 
-	/// Clears overlays for the seleted paths and removes references
+	/// Clears overlays for the selected paths and removes references
 	pub fn clear_selected(&mut self, responses: &mut VecDeque<Message>) {
 		while let Some(path) = self.selected_overlay_paths.pop() {
 			let operation = Operation::DeleteLayer { path };
diff --git a/editor/src/viewport_tools/tools/shared/transformation_cage.rs b/editor/src/viewport_tools/tools/shared/transformation_cage.rs
index 6485abcf..74ab45ee 100644
--- a/editor/src/viewport_tools/tools/shared/transformation_cage.rs
+++ b/editor/src/viewport_tools/tools/shared/transformation_cage.rs
@@ -1,4 +1,4 @@
-use crate::consts::{BOUNDS_ROTATE_THRESHOLD, BOUNDS_SELECT_THRESHOLD, COLOR_ACCENT, SELECTION_DRAG_ANGLE, VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE};
+use crate::consts::{BOUNDS_ROTATE_THRESHOLD, BOUNDS_SELECT_THRESHOLD, COLOR_ACCENT, MANIPULATOR_GROUP_MARKER_SIZE, SELECTION_DRAG_ANGLE};
 use crate::document::transformation::OriginalTransforms;
 use crate::frontend::utility_types::MouseCursorIcon;
 use crate::input::InputPreprocessorMessageHandler;
@@ -219,7 +219,7 @@ impl BoundingBoxOverlays {
 		}
 	}
 
-	/// Calculats the transformed handle positions based on the bounding box and the transform
+	/// Calculates the transformed handle positions based on the bounding box and the transform
 	pub fn evaluate_transform_handle_positions(&self) -> [DVec2; 8] {
 		let (left, top): (f64, f64) = self.bounds[0].into();
 		let (right, bottom): (f64, f64) = self.bounds[1].into();
@@ -245,7 +245,7 @@ impl BoundingBoxOverlays {
 		const BIAS: f64 = 0.0001;
 
 		for (position, path) in self.evaluate_transform_handle_positions().into_iter().zip(&self.transform_handles) {
-			let scale = DVec2::splat(VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE);
+			let scale = DVec2::splat(MANIPULATOR_GROUP_MARKER_SIZE);
 			let translation = (position - (scale / 2.) - 0.5 + BIAS).round();
 			let transform = DAffine2::from_scale_angle_translation(scale, 0., translation).to_cols_array();
 			let path = path.clone();
diff --git a/editor/src/viewport_tools/tools/text_tool.rs b/editor/src/viewport_tools/tools/text_tool.rs
index ce72805b..e4773b59 100644
--- a/editor/src/viewport_tools/tools/text_tool.rs
+++ b/editor/src/viewport_tools/tools/text_tool.rs
@@ -238,7 +238,7 @@ fn update_overlays(document: &DocumentMessageHandler, tool_data: &mut TextToolDa
 				.graphene_document
 				.layer(layer_path)
 				.unwrap()
-				.aabounding_box_for_transform(document.graphene_document.multiply_transforms(layer_path).unwrap(), font_cache)
+				.aabb_for_transform(document.graphene_document.multiply_transforms(layer_path).unwrap(), font_cache)
 				.map(|bounds| (bounds, overlay_path))
 		})
 		.collect::<Vec<_>>();
diff --git a/editor/src/viewport_tools/vector_editor/mod.rs b/editor/src/viewport_tools/vector_editor/mod.rs
index 93480221..a305ebca 100644
--- a/editor/src/viewport_tools/vector_editor/mod.rs
+++ b/editor/src/viewport_tools/vector_editor/mod.rs
@@ -1,6 +1,6 @@
 pub mod constants;
 pub mod overlay_renderer;
 pub mod shape_editor;
-use graphene::layers::vector::vector_anchor;
-use graphene::layers::vector::vector_control_point;
-use graphene::layers::vector::vector_shape;
+use graphene::layers::vector::manipulator_group;
+use graphene::layers::vector::manipulator_point;
+use graphene::layers::vector::subpath;
diff --git a/editor/src/viewport_tools/vector_editor/overlay_renderer.rs b/editor/src/viewport_tools/vector_editor/overlay_renderer.rs
index 1cc4de44..2a8e5390 100644
--- a/editor/src/viewport_tools/vector_editor/overlay_renderer.rs
+++ b/editor/src/viewport_tools/vector_editor/overlay_renderer.rs
@@ -1,47 +1,46 @@
 use super::constants::ROUNDING_BIAS;
-use super::vector_anchor::VectorAnchor;
-use super::vector_control_point::VectorControlPoint;
-use crate::consts::{COLOR_ACCENT, PATH_OUTLINE_WEIGHT, VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE};
+use super::manipulator_group::ManipulatorGroup;
+use super::manipulator_point::ManipulatorPoint;
+use crate::consts::{COLOR_ACCENT, MANIPULATOR_GROUP_MARKER_SIZE, PATH_OUTLINE_WEIGHT};
 use crate::message_prelude::{generate_uuid, DocumentMessage, Message};
 
 use graphene::color::Color;
 use graphene::document::Document;
 use graphene::layers::style::{self, Fill, Stroke};
-use graphene::layers::vector::constants::ControlPointType;
-use graphene::layers::vector::vector_shape::VectorShape;
+use graphene::layers::vector::constants::ManipulatorType;
+use graphene::layers::vector::subpath::Subpath;
 use graphene::{LayerId, Operation};
 
 use glam::{DAffine2, DVec2};
 use std::collections::{HashMap, VecDeque};
 
-/// AnchorOverlay is the collection of overlays that make up an anchor
-/// Notably the anchor point, handles and the lines for the handles
-type AnchorOverlays = [Option<Vec<LayerId>>; 5];
-type AnchorId = u64;
+/// [ManipulatorGroupOverlay]s is the collection of overlays that make up an [ManipulatorGroup] visible in the editor.
+type ManipulatorGroupOverlays = [Option<Vec<LayerId>>; 5];
+type ManipulatorId = u64;
 
 const POINT_STROKE_WEIGHT: f64 = 2.;
 
 #[derive(Clone, Debug, Default)]
 pub struct OverlayRenderer {
 	shape_overlay_cache: HashMap<LayerId, Vec<LayerId>>,
-	anchor_overlay_cache: HashMap<(LayerId, AnchorId), AnchorOverlays>,
+	manipulator_group_overlay_cache: HashMap<(LayerId, ManipulatorId), ManipulatorGroupOverlays>,
 }
 
 impl OverlayRenderer {
 	pub fn new() -> Self {
 		OverlayRenderer {
-			anchor_overlay_cache: HashMap::new(),
+			manipulator_group_overlay_cache: HashMap::new(),
 			shape_overlay_cache: HashMap::new(),
 		}
 	}
 
-	pub fn render_vector_shape_overlays(&mut self, document: &Document, layer_path: Vec<LayerId>, responses: &mut VecDeque<Message>) {
+	pub fn render_subpath_overlays(&mut self, document: &Document, layer_path: Vec<LayerId>, responses: &mut VecDeque<Message>) {
 		let transform = document.generate_transform_relative_to_viewport(&layer_path).ok().unwrap();
 		if let Ok(layer) = document.layer(&layer_path) {
 			let layer_id = layer_path.last().unwrap();
 			self.layer_overlay_visibility(document, layer_path.clone(), true, responses);
 
-			if let Some(shape) = layer.as_vector_shape() {
+			if let Some(shape) = layer.as_subpath() {
 				let outline_cache = self.shape_overlay_cache.get(layer_id);
 				log::trace!("Overlay: Outline cache {:?}", &outline_cache);
 
@@ -57,27 +56,27 @@ impl OverlayRenderer {
 					Self::place_outline_overlays(outline_path.clone(), &transform, responses);
 				}
 
-				// Create, place and style the anchor / handle overlays
-				for (anchor_id, anchor) in shape.anchors().enumerate() {
-					let anchor_cache = self.anchor_overlay_cache.get_mut(&(*layer_id, *anchor_id));
+				// Create, place, and style the manipulator overlays
+				for (manipulator_group_id, manipulator_group) in shape.manipulator_groups().enumerate() {
+					let manipulator_group_cache = self.manipulator_group_overlay_cache.get_mut(&(*layer_id, *manipulator_group_id));
 
 					// If cached update placement and style
-					if let Some(anchor_overlays) = anchor_cache {
-						log::trace!("Overlay: Updating detail overlays for {:?}", anchor_overlays);
-						Self::place_anchor_overlays(anchor, anchor_overlays, &transform, responses);
-						Self::style_overlays(anchor, anchor_overlays, responses);
+					if let Some(manipulator_group_overlays) = manipulator_group_cache {
+						log::trace!("Overlay: Updating detail overlays for {:?}", manipulator_group_overlays);
+						Self::place_manipulator_group_overlays(manipulator_group, manipulator_group_overlays, &transform, responses);
+						Self::style_overlays(manipulator_group, manipulator_group_overlays, responses);
 					} else {
 						// Create if not cached
-						let mut anchor_overlays = [
+						let mut manipulator_group_overlays = [
 							Some(self.create_anchor_overlay(responses)),
-							Self::create_handle_overlay_if_exists(&anchor.points[ControlPointType::InHandle], responses),
-							Self::create_handle_overlay_if_exists(&anchor.points[ControlPointType::OutHandle], responses),
-							Self::create_handle_line_overlay_if_exists(&anchor.points[ControlPointType::InHandle], responses),
-							Self::create_handle_line_overlay_if_exists(&anchor.points[ControlPointType::OutHandle], responses),
+							Self::create_handle_overlay_if_exists(&manipulator_group.points[ManipulatorType::InHandle], responses),
+							Self::create_handle_overlay_if_exists(&manipulator_group.points[ManipulatorType::OutHandle], responses),
+							Self::create_handle_line_overlay_if_exists(&manipulator_group.points[ManipulatorType::InHandle], responses),
+							Self::create_handle_line_overlay_if_exists(&manipulator_group.points[ManipulatorType::OutHandle], responses),
 						];
-						Self::place_anchor_overlays(anchor, &mut anchor_overlays, &transform, responses);
-						Self::style_overlays(anchor, &anchor_overlays, responses);
-						self.anchor_overlay_cache.insert((*layer_id, *anchor_id), anchor_overlays);
+						Self::place_manipulator_group_overlays(manipulator_group, &mut manipulator_group_overlays, &transform, responses);
+						Self::style_overlays(manipulator_group, &manipulator_group_overlays, responses);
+						self.manipulator_group_overlay_cache.insert((*layer_id, *manipulator_group_id), manipulator_group_overlays);
 					}
 				}
 				// TODO Handle removing shapes from cache so we don't memory leak
@@ -86,7 +85,7 @@ impl OverlayRenderer {
 		}
 	}
 
-	pub fn clear_vector_shape_overlays(&mut self, document: &Document, layer_path: Vec<LayerId>, responses: &mut VecDeque<Message>) {
+	pub fn clear_subpath_overlays(&mut self, document: &Document, layer_path: Vec<LayerId>, responses: &mut VecDeque<Message>) {
 		let layer_id = layer_path.last().unwrap();
 
 		// Remove the shape outline overlays
@@ -95,13 +94,13 @@ impl OverlayRenderer {
 		}
 		self.shape_overlay_cache.remove(layer_id);
 
-		// Remove the anchor overlays
+		// Remove the ManipulatorGroup overlays
 		if let Ok(layer) = document.layer(&layer_path) {
-			if let Some(shape) = layer.as_vector_shape() {
-				for (id, _) in shape.anchors().enumerate() {
-					if let Some(anchor_overlays) = self.anchor_overlay_cache.get(&(*layer_id, *id)) {
-						Self::remove_anchor_overlays(anchor_overlays, responses);
-						self.anchor_overlay_cache.remove(&(*layer_id, *id));
+			if let Some(shape) = layer.as_subpath() {
+				for (id, _) in shape.manipulator_groups().enumerate() {
+					if let Some(manipulator_group_overlays) = self.manipulator_group_overlay_cache.get(&(*layer_id, *id)) {
+						Self::remove_manipulator_group_overlays(manipulator_group_overlays, responses);
+						self.manipulator_group_overlay_cache.remove(&(*layer_id, *id));
 					}
 				}
 			}
@@ -116,24 +115,24 @@ impl OverlayRenderer {
 			Self::set_outline_overlay_visibility(overlay_path.clone(), visibility, responses);
 		}
 
-		// Hide the anchor overlays
+		// Hide the manipulator group overlays
 		if let Ok(layer) = document.layer(&layer_path) {
-			if let Some(shape) = layer.as_vector_shape() {
-				for (id, _) in shape.anchors().enumerate() {
-					if let Some(anchor_overlays) = self.anchor_overlay_cache.get(&(*layer_id, *id)) {
-						Self::set_anchor_overlay_visibility(anchor_overlays, visibility, responses);
+			if let Some(shape) = layer.as_subpath() {
+				for (id, _) in shape.manipulator_groups().enumerate() {
+					if let Some(manipulator_group_overlays) = self.manipulator_group_overlay_cache.get(&(*layer_id, *id)) {
+						Self::set_manipulator_group_overlay_visibility(manipulator_group_overlays, visibility, responses);
 					}
 				}
 			}
 		}
 	}
 
-	/// Create the kurbo shape that matches the selected viewport shape
-	fn create_shape_outline_overlay(&self, vector_path: VectorShape, responses: &mut VecDeque<Message>) -> Vec<LayerId> {
+	/// Create the kurbo shape that matches the selected viewport shape.
+	fn create_shape_outline_overlay(&self, subpath: Subpath, responses: &mut VecDeque<Message>) -> Vec<LayerId> {
 		let layer_path = vec![generate_uuid()];
 		let operation = Operation::AddShape {
 			path: layer_path.clone(),
-			vector_path,
+			subpath,
 			style: style::PathStyle::new(Some(Stroke::new(COLOR_ACCENT, PATH_OUTLINE_WEIGHT)), Fill::None),
 			insert_index: -1,
 			transform: DAffine2::IDENTITY.to_cols_array(),
@@ -143,7 +142,7 @@ impl OverlayRenderer {
 		layer_path
 	}
 
-	/// Create a single anchor overlay and return its layer id
+	/// Create a single anchor overlay and return its layer ID.
 	fn create_anchor_overlay(&self, responses: &mut VecDeque<Message>) -> Vec<LayerId> {
 		let layer_path = vec![generate_uuid()];
 		let operation = Operation::AddRect {
@@ -156,7 +155,7 @@ impl OverlayRenderer {
 		layer_path
 	}
 
-	/// Create a single handle overlay and return its layer id
+	/// Create a single handle overlay and return its layer ID.
 	fn create_handle_overlay(responses: &mut VecDeque<Message>) -> Vec<LayerId> {
 		let layer_path = vec![generate_uuid()];
 		let operation = Operation::AddEllipse {
@@ -169,12 +168,12 @@ impl OverlayRenderer {
 		layer_path
 	}
 
-	/// Create a single handle overlay and return its layer id if it exists
-	fn create_handle_overlay_if_exists(handle: &Option<VectorControlPoint>, responses: &mut VecDeque<Message>) -> Option<Vec<LayerId>> {
+	/// Create a single handle overlay and return its layer id if it exists.
+	fn create_handle_overlay_if_exists(handle: &Option<ManipulatorPoint>, responses: &mut VecDeque<Message>) -> Option<Vec<LayerId>> {
 		handle.as_ref().map(|_| Self::create_handle_overlay(responses))
 	}
 
-	/// Create the shape outline overlay and return its layer id
+	/// Create the shape outline overlay and return its layer ID.
 	fn create_handle_line_overlay(responses: &mut VecDeque<Message>) -> Vec<LayerId> {
 		let layer_path = vec![generate_uuid()];
 		let operation = Operation::AddLine {
@@ -187,8 +186,8 @@ impl OverlayRenderer {
 		layer_path
 	}
 
-	/// Create the shape outline overlay and return its layer id
-	fn create_handle_line_overlay_if_exists(handle: &Option<VectorControlPoint>, responses: &mut VecDeque<Message>) -> Option<Vec<LayerId>> {
+	/// Create the shape outline overlay and return its layer ID.
+	fn create_handle_line_overlay_if_exists(handle: &Option<ManipulatorPoint>, responses: &mut VecDeque<Message>) -> Option<Vec<LayerId>> {
 		handle.as_ref().map(|_| Self::create_handle_line_overlay(responses))
 	}
 
@@ -197,18 +196,18 @@ impl OverlayRenderer {
 		responses.push_back(transform_message);
 	}
 
-	fn modify_outline_overlays(outline_path: Vec<LayerId>, vector_path: VectorShape, responses: &mut VecDeque<Message>) {
-		let outline_modify_message = Self::overlay_modify_message(outline_path, vector_path);
+	fn modify_outline_overlays(outline_path: Vec<LayerId>, subpath: Subpath, responses: &mut VecDeque<Message>) {
+		let outline_modify_message = Self::overlay_modify_message(outline_path, subpath);
 		responses.push_back(outline_modify_message);
 	}
 
-	/// Updates the position of the overlays based on the VectorShape points
-	fn place_anchor_overlays(anchor: &VectorAnchor, overlays: &mut AnchorOverlays, parent_transform: &DAffine2, responses: &mut VecDeque<Message>) {
-		if let Some(anchor_point) = &anchor.points[ControlPointType::Anchor] {
-			// Helper function to keep things DRY
-			let mut place_handle_and_line = |handle: &VectorControlPoint, line_source: &mut Option<Vec<LayerId>>, marker_source: &mut Option<Vec<LayerId>>| {
+	/// Updates the position of the overlays based on the [Subpath] points.
+	fn place_manipulator_group_overlays(manipulator_group: &ManipulatorGroup, overlays: &mut ManipulatorGroupOverlays, parent_transform: &DAffine2, responses: &mut VecDeque<Message>) {
+		if let Some(manipulator_point) = &manipulator_group.points[ManipulatorType::Anchor] {
+			// Helper function to keep things DRY (don't-repeat-yourself)
+			let mut place_handle_and_line = |handle: &ManipulatorPoint, line_source: &mut Option<Vec<LayerId>>, marker_source: &mut Option<Vec<LayerId>>| {
 				let line_overlay = line_source.take().unwrap_or_else(|| Self::create_handle_line_overlay(responses));
-				let line_vector = parent_transform.transform_point2(anchor_point.position) - parent_transform.transform_point2(handle.position);
+				let line_vector = parent_transform.transform_point2(manipulator_point.position) - parent_transform.transform_point2(handle.position);
 				let scale = DVec2::splat(line_vector.length());
 				let angle = -line_vector.angle_between(DVec2::X);
 				let translation = (parent_transform.transform_point2(handle.position) + ROUNDING_BIAS).round() + DVec2::splat(0.5);
@@ -217,7 +216,7 @@ impl OverlayRenderer {
 				*line_source = Some(line_overlay);
 
 				let marker_overlay = marker_source.take().unwrap_or_else(|| Self::create_handle_overlay(responses));
-				let scale = DVec2::splat(VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE);
+				let scale = DVec2::splat(MANIPULATOR_GROUP_MARKER_SIZE);
 				let angle = 0.;
 				let translation = (parent_transform.transform_point2(handle.position) - (scale / 2.) + ROUNDING_BIAS).round();
 				let transform = DAffine2::from_scale_angle_translation(scale, angle, translation).to_cols_array();
@@ -226,7 +225,7 @@ impl OverlayRenderer {
 			};
 
 			// Place the handle overlays
-			let [_, h1, h2] = &anchor.points;
+			let [_, h1, h2] = &manipulator_group.points;
 			let [a, b, c, line1, line2] = overlays;
 			let markers = [a, b, c];
 			if let Some(handle) = &h1 {
@@ -237,10 +236,10 @@ impl OverlayRenderer {
 			}
 
 			// Place the anchor point overlay
-			if let Some(anchor_overlay) = &overlays[ControlPointType::Anchor as usize] {
-				let scale = DVec2::splat(VECTOR_MANIPULATOR_ANCHOR_MARKER_SIZE);
+			if let Some(anchor_overlay) = &overlays[ManipulatorType::Anchor as usize] {
+				let scale = DVec2::splat(MANIPULATOR_GROUP_MARKER_SIZE);
 				let angle = 0.;
-				let translation = (parent_transform.transform_point2(anchor_point.position) - (scale / 2.) + ROUNDING_BIAS).round();
+				let translation = (parent_transform.transform_point2(manipulator_point.position) - (scale / 2.) + ROUNDING_BIAS).round();
 				let transform = DAffine2::from_scale_angle_translation(scale, angle, translation).to_cols_array();
 
 				let message = Self::overlay_transform_message(anchor_overlay.clone(), transform);
@@ -249,8 +248,8 @@ impl OverlayRenderer {
 		}
 	}
 
-	/// Removes the anchor / handle overlays from the overlay document
-	fn remove_anchor_overlays(overlay_paths: &AnchorOverlays, responses: &mut VecDeque<Message>) {
+	/// Removes the manipulator overlays from the overlay document.
+	fn remove_manipulator_group_overlays(overlay_paths: &ManipulatorGroupOverlays, responses: &mut VecDeque<Message>) {
 		overlay_paths.iter().flatten().for_each(|layer_id| {
 			log::trace!("Overlay: Sending delete message for: {:?}", layer_id);
 			responses.push_back(DocumentMessage::Overlays(Operation::DeleteLayer { path: layer_id.clone() }.into()).into());
@@ -261,9 +260,9 @@ impl OverlayRenderer {
 		responses.push_back(DocumentMessage::Overlays(Operation::DeleteLayer { path: overlay_path }.into()).into());
 	}
 
-	/// Sets the visibility of the handles overlay
-	fn set_anchor_overlay_visibility(anchor_overlays: &AnchorOverlays, visibility: bool, responses: &mut VecDeque<Message>) {
-		anchor_overlays.iter().flatten().for_each(|layer_id| {
+	/// Sets the visibility of the handles overlay.
+	fn set_manipulator_group_overlay_visibility(manipulator_group_overlays: &ManipulatorGroupOverlays, visibility: bool, responses: &mut VecDeque<Message>) {
+		manipulator_group_overlays.iter().flatten().for_each(|layer_id| {
 			responses.push_back(Self::overlay_visibility_message(layer_id.clone(), visibility));
 		});
 	}
@@ -272,7 +271,7 @@ impl OverlayRenderer {
 		responses.push_back(Self::overlay_visibility_message(overlay_path, visibility));
 	}
 
-	/// Create a visibility message for an overlay
+	/// Create a visibility message for an overlay.
 	fn overlay_visibility_message(layer_path: Vec<LayerId>, visibility: bool) -> Message {
 		DocumentMessage::Overlays(
 			Operation::SetLayerVisibility {
@@ -284,28 +283,27 @@ impl OverlayRenderer {
 		.into()
 	}
 
-	/// Create a transform message for an overlay
+	/// Create a transform message for an overlay.
 	fn overlay_transform_message(layer_path: Vec<LayerId>, transform: [f64; 6]) -> Message {
 		DocumentMessage::Overlays(Operation::SetLayerTransformInViewport { path: layer_path, transform }.into()).into()
 	}
 
-	/// Create an update message for an overlay
-	fn overlay_modify_message(layer_path: Vec<LayerId>, vector_path: VectorShape) -> Message {
-		DocumentMessage::Overlays(Operation::SetShapePath { path: layer_path, vector_path }.into()).into()
+	/// Create an update message for an overlay.
+	fn overlay_modify_message(layer_path: Vec<LayerId>, subpath: Subpath) -> Message {
+		DocumentMessage::Overlays(Operation::SetShapePath { path: layer_path, subpath }.into()).into()
 	}
 
-	/// Sets the overlay style for this point
-	fn style_overlays(anchor: &VectorAnchor, overlays: &AnchorOverlays, responses: &mut VecDeque<Message>) {
-		// TODO Move the style definitions out of the VectorShape, should be looked up from a stylesheet or similar
+	/// Sets the overlay style for this point.
+	fn style_overlays(manipulator_group: &ManipulatorGroup, overlays: &ManipulatorGroupOverlays, responses: &mut VecDeque<Message>) {
+		// TODO Move the style definitions out of the Subpath, should be looked up from a stylesheet or similar
 		let selected_style = style::PathStyle::new(Some(Stroke::new(COLOR_ACCENT, POINT_STROKE_WEIGHT + 1.0)), Fill::solid(COLOR_ACCENT));
 		let deselected_style = style::PathStyle::new(Some(Stroke::new(COLOR_ACCENT, POINT_STROKE_WEIGHT)), Fill::solid(Color::WHITE));
 
-		// Update if the anchor / handle points are shown as selected
+		// Update if the manipulator points are shown as selected
 		// Here the index is important, even though overlays[..] has five elements we only care about the first three
-		for (index, point) in anchor.points.iter().enumerate() {
+		for (index, point) in manipulator_group.points.iter().enumerate() {
 			if let Some(point) = point {
 				if let Some(overlay) = &overlays[index] {
-					// log::debug!("style_overlays: {:?}", &overlay);
 					let style = if point.editor_state.is_selected { selected_style.clone() } else { deselected_style.clone() };
 					responses.push_back(DocumentMessage::Overlays(Operation::SetLayerStyle { path: overlay.clone(), style }.into()).into());
 				}
diff --git a/editor/src/viewport_tools/vector_editor/shape_editor.rs b/editor/src/viewport_tools/vector_editor/shape_editor.rs
index 7ad3d934..82215450 100644
--- a/editor/src/viewport_tools/vector_editor/shape_editor.rs
+++ b/editor/src/viewport_tools/vector_editor/shape_editor.rs
@@ -1,37 +1,38 @@
-// Overview:
-//          ShapeEditor
-//         /          \
-//      selected_shape_layers <- Paths to selected layers that may contain VectorShapes
-//        |               |
-//  VectorShape ... VectorShape  <- Reference from layer paths, one Vectorshape per layer
-//      /                 \
-//  VectorAnchor ...  VectorAnchor <- VectorShape contains many VectorAnchors
-
-use super::vector_anchor::VectorAnchor;
-use super::vector_control_point::VectorControlPoint;
-use super::vector_shape::VectorShape;
+use super::manipulator_group::ManipulatorGroup;
+use super::manipulator_point::ManipulatorPoint;
+use super::subpath::Subpath;
 use crate::message_prelude::{DocumentMessage, Message};
 
-use graphene::layers::vector::constants::ControlPointType;
+use graphene::layers::vector::constants::ManipulatorType;
 use graphene::{LayerId, Operation};
 
 use glam::DVec2;
 use graphene::document::Document;
 use std::collections::VecDeque;
 
-/// ShapeEditor is the container for all of the layer paths that are
-/// represented as VectorShapes and provides functionality required
-/// to query and create the VectorShapes / VectorAnchors / VectorControlPoints
+/// ShapeEditor is the container for all of the layer paths that are represented as [Subpath]s and provides
+/// functionality required to query and create the [Subpath] / [ManipulatorGroup]s / [ManipulatorPoint]s.
+///
+/// Overview:
+/// ```text
+///              ShapeEditor
+///                   |
+///            selected_layers               <- Paths to selected layers that may contain Subpaths
+///              /    |    \
+///          Subpath ... Subpath             <- Reference from layer paths, one Subpath per layer (for now, will eventually be a CompoundPath)
+///            /      |      \
+/// ManipulatorGroup ... ManipulatorGroup    <- Subpath contains many ManipulatorGroups
+/// ```
 #[derive(Clone, Debug, Default)]
 pub struct ShapeEditor {
-	// The layers we can select and edit anchors / handles from
+	// The layers we can select and edit manipulators (anchors and handles) from
 	selected_layers: Vec<Vec<LayerId>>,
 }
 
-// TODO Consider keeping a list of selected anchors to minimize traversals of the layers
+// TODO Consider keeping a list of selected manipulators to minimize traversals of the layers
 impl ShapeEditor {
-	/// Select the first point within the selection threshold
-	/// Returns the points if found, none otherwise
+	/// Select the first point within the selection threshold.
+	/// Returns the points if found, None otherwise.
 	pub fn select_point(
 		&self,
 		document: &Document,
@@ -39,23 +40,23 @@ impl ShapeEditor {
 		select_threshold: f64,
 		add_to_selection: bool,
 		responses: &mut VecDeque<Message>,
-	) -> Option<Vec<(&[LayerId], u64, ControlPointType)>> {
+	) -> Option<Vec<(&[LayerId], u64, ManipulatorType)>> {
 		if self.selected_layers.is_empty() {
 			return None;
 		}
 
-		if let Some((shape_layer_path, anchor_id, point_index)) = self.find_nearest_point_indicies(document, mouse_position, select_threshold) {
-			log::trace!("Selecting: anchor {} / point {}", anchor_id, point_index);
+		if let Some((shape_layer_path, manipulator_group_id, manipulator_point_index)) = self.find_nearest_point_indices(document, mouse_position, select_threshold) {
+			log::trace!("Selecting... manipulator group ID: {}, manipulator point index: {}", manipulator_group_id, manipulator_point_index);
 
 			// If the point we're selecting has already been selected
-			// we can assume this point exists.. since we did just click on it hense the unwrap
-			let is_point_selected = self.shape(document, shape_layer_path).unwrap().anchors().by_id(anchor_id).unwrap().points[point_index]
+			// we can assume this point exists.. since we did just click on it hence the unwrap
+			let is_point_selected = self.shape(document, shape_layer_path).unwrap().manipulator_groups().by_id(manipulator_group_id).unwrap().points[manipulator_point_index]
 				.as_ref()
 				.unwrap()
 				.editor_state
 				.is_selected;
 
-			let point_position = self.shape(document, shape_layer_path).unwrap().anchors().by_id(anchor_id).unwrap().points[point_index]
+			let point_position = self.shape(document, shape_layer_path).unwrap().manipulator_groups().by_id(manipulator_group_id).unwrap().points[manipulator_point_index]
 				.as_ref()
 				.unwrap()
 				.position;
@@ -65,35 +66,33 @@ impl ShapeEditor {
 				.selected_layers()
 				.iter()
 				.filter_map(|path| document.layer(path).ok().map(|layer| (path, layer)))
-				.filter_map(|(path, shape)| shape.as_vector_shape().map(|vector| (path, vector)))
+				.filter_map(|(path, shape)| shape.as_subpath().map(|subpath| (path, subpath)))
 				.flat_map(|(path, shape)| {
 					shape
-						.anchors()
+						.manipulator_groups()
 						.enumerate()
-						.filter(|(_id, anchor)| anchor.is_anchor_selected())
-						.flat_map(|(id, anchor)| anchor.selected_points().map(move |point| (id, point.manipulator_type)))
-						.map(|(anchor, control_point)| (path.as_slice(), *anchor, control_point))
+						.filter(|(_id, manipulator_group)| manipulator_group.is_anchor_selected())
+						.flat_map(|(id, manipulator_group)| manipulator_group.selected_points().map(move |point| (id, point.manipulator_type)))
+						.map(|(anchor, manipulator_point)| (path.as_slice(), *anchor, manipulator_point))
 				})
 				.collect::<Vec<_>>();
 
-			// let selected_shape = self.shape(document, shape_layer_path).unwrap();
-
 			// Should we select or deselect the point?
 			let should_select = if is_point_selected { !add_to_selection } else { true };
 
-			// This is selecting the anchor only for now, next to generalize to points
+			// This is selecting the manipulator only for now, next to generalize to points
 			if should_select {
 				let add = add_to_selection || is_point_selected;
-				let point = (anchor_id, ControlPointType::from_index(point_index));
+				let point = (manipulator_group_id, ManipulatorType::from_index(manipulator_point_index));
 				// Clear all point in other selected shapes
-				if !(add) {
-					responses.push_back(DocumentMessage::DeselectAllVectorPoints.into());
+				if !add {
+					responses.push_back(DocumentMessage::DeselectAllManipulatorPoints.into());
 					points = vec![(shape_layer_path, point.0, point.1)];
 				} else {
 					points.push((shape_layer_path, point.0, point.1));
 				}
 				responses.push_back(
-					Operation::SelectVectorPoints {
+					Operation::SelectManipulatorPoints {
 						layer_path: shape_layer_path.to_vec(),
 						point_ids: vec![point],
 						add,
@@ -106,34 +105,34 @@ impl ShapeEditor {
 				}
 			} else {
 				responses.push_back(
-					Operation::DeselectVectorPoints {
+					Operation::DeselectManipulatorPoints {
 						layer_path: shape_layer_path.to_vec(),
-						point_ids: vec![(anchor_id, ControlPointType::from_index(point_index))],
+						point_ids: vec![(manipulator_group_id, ManipulatorType::from_index(manipulator_point_index))],
 					}
 					.into(),
 				);
-				points.retain(|x| *x != (shape_layer_path, anchor_id, ControlPointType::from_index(point_index)))
+				points.retain(|x| *x != (shape_layer_path, manipulator_group_id, ManipulatorType::from_index(manipulator_point_index)))
 			}
 
 			return Some(points);
 		}
 
 		// Deselect all points if no nearby point
-		responses.push_back(DocumentMessage::DeselectAllVectorPoints.into());
+		responses.push_back(DocumentMessage::DeselectAllManipulatorPoints.into());
 		None
 	}
 
-	/// A wrapper for find_nearest_point_indicies and returns a VectorControlPoint
-	pub fn find_nearest_point<'a>(&'a self, document: &'a Document, mouse_position: DVec2, select_threshold: f64) -> Option<&'a VectorControlPoint> {
-		let (shape_layer_path, anchor_id, point_index) = self.find_nearest_point_indicies(document, mouse_position, select_threshold)?;
+	/// A wrapper for `find_nearest_point_indices()` and returns a [ManipulatorPoint].
+	pub fn find_nearest_point<'a>(&'a self, document: &'a Document, mouse_position: DVec2, select_threshold: f64) -> Option<&'a ManipulatorPoint> {
+		let (shape_layer_path, manipulator_group_id, manipulator_point_index) = self.find_nearest_point_indices(document, mouse_position, select_threshold)?;
 		let selected_shape = self.shape(document, shape_layer_path).unwrap();
-		if let Some(anchor) = selected_shape.anchors().by_id(anchor_id) {
-			return anchor.points[point_index].as_ref();
+		if let Some(manipulator_group) = selected_shape.manipulator_groups().by_id(manipulator_group_id) {
+			return manipulator_group.points[manipulator_point_index].as_ref();
 		}
 		None
 	}
 
-	/// Set the shapes we consider for selection, we will choose draggable handles / anchors from these shapes.
+	/// Set the shapes we consider for selection, we will choose draggable manipulators from these shapes.
 	pub fn set_selected_layers(&mut self, target_layers: Vec<Vec<LayerId>>) {
 		self.selected_layers = target_layers;
 	}
@@ -146,7 +145,7 @@ impl ShapeEditor {
 		self.selected_layers.iter().map(|l| l.as_slice()).collect::<Vec<_>>()
 	}
 
-	/// Clear all of the shapes we can modify
+	/// Clear all of the shapes we can modify.
 	pub fn clear_selected_layers(&mut self) {
 		self.selected_layers.clear();
 	}
@@ -155,26 +154,26 @@ impl ShapeEditor {
 		!self.selected_layers.is_empty()
 	}
 
-	/// Provide the currently selected anchor by reference
-	pub fn selected_anchors<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a VectorAnchor> {
-		self.iter(document).flat_map(|shape| shape.selected_anchors())
+	/// Provide the currently selected manipulators by reference.
+	pub fn selected_manipulator_groups<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a ManipulatorGroup> {
+		self.iter(document).flat_map(|shape| shape.selected_manipulator_groups())
 	}
 
-	/// A mutable iterator of all the anchors, regardless of selection
-	pub fn anchors<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a VectorAnchor> {
-		self.iter(document).flat_map(|shape| shape.anchors().iter())
+	/// A mutable iterator of all the manipulators, regardless of selection.
+	pub fn manipulator_groups<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a ManipulatorGroup> {
+		self.iter(document).flat_map(|shape| shape.manipulator_groups().iter())
 	}
 
-	/// Provide the currently selected points by reference
-	pub fn selected_points<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a VectorControlPoint> {
-		self.selected_anchors(document).flat_map(|anchors| anchors.selected_points())
+	/// Provide the currently selected points by reference.
+	pub fn selected_points<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a ManipulatorPoint> {
+		self.selected_manipulator_groups(document).flat_map(|manipulator_group| manipulator_group.selected_points())
 	}
 
-	/// Move the selected points by dragging the moue
+	/// Move the selected points by dragging the mouse.
 	pub fn move_selected_points(&self, delta: DVec2, absolute_position: DVec2, responses: &mut VecDeque<Message>) {
 		for layer_path in &self.selected_layers {
 			responses.push_back(
-				DocumentMessage::MoveSelectedVectorPoints {
+				DocumentMessage::MoveSelectedManipulatorPoints {
 					layer_path: layer_path.clone(),
 					delta: (delta.x, delta.y),
 					absolute_position: (absolute_position.x, absolute_position.y),
@@ -184,12 +183,12 @@ impl ShapeEditor {
 		}
 	}
 
-	/// Dissolve the selected points
+	/// Dissolve the selected points.
 	pub fn delete_selected_points(&self, responses: &mut VecDeque<Message>) {
-		responses.push_back(DocumentMessage::DeleteSelectedVectorPoints.into());
+		responses.push_back(DocumentMessage::DeleteSelectedManipulatorPoints.into());
 	}
 
-	/// Toggle if the handles should mirror angle across the anchor positon
+	/// Toggle if the handles should mirror angle across the anchor position.
 	pub fn toggle_handle_mirroring_on_selected(&self, toggle_angle: bool, toggle_distance: bool, responses: &mut VecDeque<Message>) {
 		for layer_path in &self.selected_layers {
 			responses.push_back(
@@ -203,18 +202,19 @@ impl ShapeEditor {
 		}
 	}
 
-	/// Deselect all anchors from the shapes the manipulation handler has created
+	/// Deselect all manipulators from the shapes that the manipulation handler has created.
 	pub fn deselect_all_points(&self, responses: &mut VecDeque<Message>) {
-		responses.push_back(DocumentMessage::DeselectAllVectorPoints.into());
+		responses.push_back(DocumentMessage::DeselectAllManipulatorPoints.into());
 	}
 
-	/// Iterate over the shapes
-	pub fn iter<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a VectorShape> + 'a {
-		self.selected_layers.iter().flat_map(|layer_id| document.layer(layer_id)).filter_map(|shape| shape.as_vector_shape())
+	/// Iterate over the shapes.
+	pub fn iter<'a>(&'a self, document: &'a Document) -> impl Iterator<Item = &'a Subpath> + 'a {
+		self.selected_layers.iter().flat_map(|layer_id| document.layer(layer_id)).filter_map(|shape| shape.as_subpath())
 	}
 
-	/// Find a point that is within the selection threshold and return an index to the shape, anchor, and point
-	fn find_nearest_point_indicies(&self, document: &Document, mouse_position: DVec2, select_threshold: f64) -> Option<(&[LayerId], u64, usize)> {
+	/// Find a [ManipulatorPoint] that is within the selection threshold and return the layer path, an index to the [ManipulatorGroup], and an enum index for [ManipulatorPoint].
+	/// Return value is an `Option` of the tuple representing `(layer path, ManipulatorGroup ID, ManipulatorType enum index)`.
+	fn find_nearest_point_indices(&self, document: &Document, mouse_position: DVec2, select_threshold: f64) -> Option<(&[LayerId], u64, usize)> {
 		if self.selected_layers.is_empty() {
 			return None;
 		}
@@ -222,34 +222,36 @@ impl ShapeEditor {
 		let select_threshold_squared = select_threshold * select_threshold;
 		// Find the closest control point among all elements of shapes_to_modify
 		for layer in self.selected_layers.iter() {
-			if let Some((anchor_id, point_index, distance_squared)) = self.closest_point_in_layer(document, layer, mouse_position) {
+			if let Some((manipulator_id, manipulator_point_index, distance_squared)) = self.closest_point_in_layer(document, layer, mouse_position) {
 				// Choose the first point under the threshold
 				if distance_squared < select_threshold_squared {
-					log::trace!("Selecting: anchor {} / point {}", anchor_id, point_index);
-					return Some((layer, anchor_id, point_index));
+					log::trace!("Selecting... manipulator ID: {}, manipulator point index: {}", manipulator_id, manipulator_point_index);
+					return Some((layer, manipulator_id, manipulator_point_index));
 				}
 			}
 		}
+
 		None
 	}
 
 	// TODO Use quadtree or some equivalent spatial acceleration structure to improve this to O(log(n))
-	/// Find the closest point, anchor and distance so we can select path elements
-	/// Brute force comparison to determine which handle / anchor we want to select, O(n)
+	/// Find the closest manipulator, manipulator point, and distance so we can select path elements.
+	/// Brute force comparison to determine which manipulator (handle or anchor) we want to select taking O(n) time.
+	/// Return value is an `Option` of the tuple representing `(manipulator ID, manipulator point index, distance squared)`.
 	fn closest_point_in_layer(&self, document: &Document, layer_path: &[LayerId], pos: glam::DVec2) -> Option<(u64, usize, f64)> {
 		let mut closest_distance_squared: f64 = f64::MAX; // Not ideal
 		let mut result: Option<(u64, usize, f64)> = None;
 
-		if let Some(shape) = document.layer(layer_path).ok()?.as_vector_shape() {
+		if let Some(shape) = document.layer(layer_path).ok()?.as_subpath() {
 			let viewspace = document.generate_transform_relative_to_viewport(layer_path).ok()?;
-			for (anchor_id, anchor) in shape.anchors().enumerate() {
-				let point_index = anchor.closest_point(&viewspace, pos);
-				if let Some(point) = &anchor.points[point_index] {
+			for (manipulator_id, manipulator) in shape.manipulator_groups().enumerate() {
+				let manipulator_point_index = manipulator.closest_point(&viewspace, pos);
+				if let Some(point) = &manipulator.points[manipulator_point_index] {
 					if point.editor_state.can_be_selected {
 						let distance_squared = viewspace.transform_point2(point.position).distance_squared(pos);
 						if distance_squared < closest_distance_squared {
 							closest_distance_squared = distance_squared;
-							result = Some((*anchor_id, point_index, distance_squared));
+							result = Some((*manipulator_id, manipulator_point_index, distance_squared));
 						}
 					}
 				}
@@ -258,7 +260,7 @@ impl ShapeEditor {
 		result
 	}
 
-	fn shape<'a>(&'a self, document: &'a Document, layer_id: &[u64]) -> Option<&'a VectorShape> {
-		document.layer(layer_id).ok()?.as_vector_shape()
+	fn shape<'a>(&'a self, document: &'a Document, layer_id: &[u64]) -> Option<&'a Subpath> {
+		document.layer(layer_id).ok()?.as_subpath()
 	}
 }
diff --git a/graphene/src/boolean_ops.rs b/graphene/src/boolean_ops.rs
index 7cd0d8d3..b99713a2 100644
--- a/graphene/src/boolean_ops.rs
+++ b/graphene/src/boolean_ops.rs
@@ -535,7 +535,7 @@ pub fn composite_boolean_operation(mut select: BooleanOperation, shapes: &mut Ve
 // TODO: check if shapes are filled
 // TODO: Bug: shape with at least two subpaths and comprised of many unions sometimes has erroneous movetos embedded in edges
 pub fn boolean_operation(mut select: BooleanOperation, alpha: &mut ShapeLayer, beta: &mut ShapeLayer) -> Result<Vec<ShapeLayer>, BooleanOperationError> {
-	if alpha.shape.anchors().is_empty() || beta.shape.anchors().is_empty() {
+	if alpha.shape.manipulator_groups().is_empty() || beta.shape.manipulator_groups().is_empty() {
 		return Err(BooleanOperationError::InvalidSelection);
 	}
 	if select == BooleanOperation::SubtractBack {
diff --git a/graphene/src/document.rs b/graphene/src/document.rs
index edafc590..add2e169 100644
--- a/graphene/src/document.rs
+++ b/graphene/src/document.rs
@@ -6,7 +6,7 @@ use crate::layers::layer_info::{Layer, LayerData, LayerDataType, LayerDataTypeDi
 use crate::layers::shape_layer::ShapeLayer;
 use crate::layers::style::RenderData;
 use crate::layers::text_layer::{Font, FontCache, TextLayer};
-use crate::layers::vector::vector_shape::VectorShape;
+use crate::layers::vector::subpath::Subpath;
 use crate::{DocumentError, DocumentResponse, Operation};
 
 use glam::{DAffine2, DVec2};
@@ -126,28 +126,28 @@ impl Document {
 		Ok(shapes)
 	}
 
-	/// Return a copy of all VectorShapes currently in the document.
-	pub fn all_vector_shapes(&self) -> Vec<VectorShape> {
-		self.root.iter().flat_map(|layer| layer.as_vector_shape_copy()).collect::<Vec<VectorShape>>()
+	/// Return a copy of all [Subpath]s currently in the document.
+	pub fn all_subpaths(&self) -> Vec<Subpath> {
+		self.root.iter().flat_map(|layer| layer.as_subpath_copy()).collect::<Vec<Subpath>>()
 	}
 
-	/// Returns references to all VectorShapes currently in the document.
-	pub fn all_vector_shapes_ref(&self) -> Vec<&VectorShape> {
-		self.root.iter().flat_map(|layer| layer.as_vector_shape()).collect::<Vec<&VectorShape>>()
+	/// Returns references to all [Subpath]s currently in the document.
+	pub fn all_subpaths_ref(&self) -> Vec<&Subpath> {
+		self.root.iter().flat_map(|layer| layer.as_subpath()).collect::<Vec<&Subpath>>()
 	}
 
-	/// Returns a reference to the requested VectorShape by providing a path to its owner layer.
-	pub fn vector_shape_ref<'a>(&'a self, path: &[LayerId]) -> Option<&'a VectorShape> {
-		self.layer(path).ok()?.as_vector_shape()
+	/// Returns a reference to the requested [Subpath] by providing a path to its owner layer.
+	pub fn subpath_ref<'a>(&'a self, path: &[LayerId]) -> Option<&'a Subpath> {
+		self.layer(path).ok()?.as_subpath()
 	}
 
-	/// Returns a mutable reference of the requested VectorShape by providing a path to its owner layer.
-	pub fn vector_shape_mut<'a>(&'a mut self, path: &'a [LayerId]) -> Option<&'a mut VectorShape> {
-		self.layer_mut(path).ok()?.as_vector_shape_mut()
+	/// Returns a mutable reference of the requested [Subpath] by providing a path to its owner layer.
+	pub fn subpath_mut<'a>(&'a mut self, path: &'a [LayerId]) -> Option<&'a mut Subpath> {
+		self.layer_mut(path).ok()?.as_subpath_mut()
 	}
 
-	/// Set a VectorShape at the specified path.
-	pub fn set_vector_shape(&mut self, path: &[LayerId], shape: VectorShape) {
+	/// Set a [Subpath] at the specified path.
+	pub fn set_subpath(&mut self, path: &[LayerId], shape: Subpath) {
 		let layer = self.layer_mut(path);
 		if let Ok(layer) = layer {
 			if let LayerDataType::Shape(shape_layer) = &mut layer.data {
@@ -158,9 +158,9 @@ impl Document {
 		}
 	}
 
-	/// Set VectorShapes for multiple paths at once.
-	pub fn set_vector_shapes<'a>(&'a mut self, paths: impl Iterator<Item = &'a [LayerId]>, shapes: Vec<VectorShape>) {
-		paths.zip(shapes).for_each(|(path, shape)| self.set_vector_shape(path, shape));
+	/// Set [Subpath]s for multiple paths at once.
+	pub fn set_subpaths<'a>(&'a mut self, paths: impl Iterator<Item = &'a [LayerId]>, shapes: Vec<Subpath>) {
+		paths.zip(shapes).for_each(|(path, shape)| self.set_subpath(path, shape));
 	}
 
 	pub fn common_layer_path_prefix<'a>(&self, layers: impl Iterator<Item = &'a [LayerId]>) -> &'a [LayerId] {
@@ -591,9 +591,9 @@ impl Document {
 				transform,
 				insert_index,
 				style,
-				vector_path,
+				subpath,
 			} => {
-				let shape = ShapeLayer::new(vector_path, style);
+				let shape = ShapeLayer::new(subpath, style);
 				self.set_layer(&path, Layer::new(LayerDataType::Shape(shape), transform), insert_index)?;
 				Some([vec![DocumentChanged, CreatedLayer { path }]].concat())
 			}
@@ -758,53 +758,61 @@ impl Document {
 				self.mark_as_dirty(&path)?;
 				Some([vec![DocumentChanged], update_thumbnails_upstream(&path)].concat())
 			}
-			Operation::SetShapePath { path, vector_path } => {
+			Operation::SetShapePath { path, subpath } => {
 				self.mark_as_dirty(&path)?;
 
 				if let LayerDataType::Shape(shape) = &mut self.layer_mut(&path)?.data {
-					shape.shape = vector_path;
+					shape.shape = subpath;
 				}
 				Some(vec![DocumentChanged, LayerChanged { path }])
 			}
-			Operation::InsertVectorAnchor { layer_path, anchor, after_id } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_vector_shape_mut()) {
-					shape.anchors_mut().insert(anchor, after_id);
+			Operation::InsertManipulatorGroup {
+				layer_path,
+				manipulator_group,
+				after_id,
+			} => {
+				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
+					shape.manipulator_groups_mut().insert(manipulator_group, after_id);
 					self.mark_as_dirty(&layer_path)?;
 				}
 				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
 			}
-			Operation::PushVectorAnchor { layer_path, anchor } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_vector_shape_mut()) {
-					shape.anchors_mut().push(anchor);
+			Operation::PushManipulatorGroup { layer_path, manipulator_group } => {
+				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
+					shape.manipulator_groups_mut().push(manipulator_group);
 					self.mark_as_dirty(&layer_path)?;
 				}
 				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
 			}
-			Operation::RemoveVectorAnchor { layer_path, id } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_vector_shape_mut()) {
-					shape.anchors_mut().remove(id);
+			Operation::RemoveManipulatorGroup { layer_path, id } => {
+				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
+					shape.manipulator_groups_mut().remove(id);
 					self.mark_as_dirty(&layer_path)?;
 				}
 				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
 			}
-			Operation::MoveVectorPoint {
+			Operation::MoveManipulatorPoint {
 				layer_path,
 				id,
-				control_type,
+				manipulator_type: control_type,
 				position,
 			} => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_vector_shape_mut()) {
-					if let Some(anchor) = shape.anchors_mut().by_id_mut(id) {
-						anchor.set_point_position(control_type as usize, position.into());
+				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
+					if let Some(manipulator_group) = shape.manipulator_groups_mut().by_id_mut(id) {
+						manipulator_group.set_point_position(control_type as usize, position.into());
 						self.mark_as_dirty(&layer_path)?;
 					}
 				}
 				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
 			}
-			Operation::RemoveVectorPoint { layer_path, id, control_type } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_vector_shape_mut()) {
-					if let Some(anchor) = shape.anchors_mut().by_id_mut(id) {
-						anchor.points[control_type as usize] = None;
+			Operation::RemoveManipulatorPoint {
+				layer_path,
+				id,
+				manipulator_type: control_type,
+			} => {
+				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
+					if let Some(manipulator_group) = shape.manipulator_groups_mut().by_id_mut(id) {
+						manipulator_group.points[control_type as usize] = None;
 						self.mark_as_dirty(&layer_path)?;
 					}
 				}
@@ -886,47 +894,47 @@ impl Document {
 			}
 
 			// We may not want the concept of selection here. For now leaving though.
-			Operation::SelectVectorPoints { layer_path, point_ids, add } => {
+			Operation::SelectManipulatorPoints { layer_path, point_ids, add } => {
 				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_vector_shape_mut() {
+				if let Some(shape) = layer.as_subpath_mut() {
 					if !add {
-						shape.clear_selected_anchors();
+						shape.clear_selected_manipulator_groups();
 					}
 					shape.select_points(&point_ids, true);
 				}
 				Some(vec![LayerChanged { path: layer_path.clone() }])
 			}
-			Operation::DeselectVectorPoints { layer_path, point_ids } => {
+			Operation::DeselectManipulatorPoints { layer_path, point_ids } => {
 				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_vector_shape_mut() {
+				if let Some(shape) = layer.as_subpath_mut() {
 					shape.select_points(&point_ids, false);
 				}
 				Some(vec![LayerChanged { path: layer_path.clone() }])
 			}
-			Operation::DeselectAllVectorPoints { layer_path } => {
+			Operation::DeselectAllManipulatorPoints { layer_path } => {
 				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_vector_shape_mut() {
-					shape.clear_selected_anchors();
+				if let Some(shape) = layer.as_subpath_mut() {
+					shape.clear_selected_manipulator_groups();
 				}
 				Some(vec![LayerChanged { path: layer_path.clone() }])
 			}
-			Operation::DeleteSelectedVectorPoints { layer_paths } => {
+			Operation::DeleteSelectedManipulatorPoints { layer_paths } => {
 				let mut responses = vec![];
 				for layer_path in layer_paths {
 					let layer = self.layer_mut(&layer_path)?;
-					if let Some(shape) = layer.as_vector_shape_mut() {
+					if let Some(shape) = layer.as_subpath_mut() {
 						// Delete the selected points.
 						shape.delete_selected();
 
-						// Delete the layer if there are no longer any anchors
-						if (shape.anchors().len() - 1) == 0 {
+						// Delete the layer if there are no longer any manipulator groups
+						if (shape.manipulator_groups().len() - 1) == 0 {
 							self.delete(&layer_path)?;
 							responses.push(DocumentChanged);
 							responses.push(DocumentResponse::DeletedLayer { path: layer_path });
 							return Ok(Some(responses));
 						}
 
-						// If we still have anchors, update the layer and thumbnails
+						// If we still have manipulator groups, update the layer and thumbnails
 						self.mark_as_dirty(&layer_path)?;
 						responses.push(DocumentChanged);
 						responses.push(LayerChanged { path: layer_path.clone() });
@@ -935,13 +943,13 @@ impl Document {
 				}
 				Some(responses)
 			}
-			Operation::MoveSelectedVectorPoints { layer_path, delta, absolute_position } => {
+			Operation::MoveSelectedManipulatorPoints { layer_path, delta, absolute_position } => {
 				if let Ok(viewspace) = self.generate_transform_relative_to_viewport(&layer_path) {
 					let objectspace = &viewspace.inverse();
 					let delta = objectspace.transform_vector2(DVec2::new(delta.0, delta.1));
 					let absolute_position = objectspace.transform_point2(DVec2::new(absolute_position.0, absolute_position.1));
 					let layer = self.layer_mut(&layer_path)?;
-					if let Some(shape) = layer.as_vector_shape_mut() {
+					if let Some(shape) = layer.as_subpath_mut() {
 						shape.move_selected(delta, absolute_position, &viewspace);
 					}
 				}
@@ -954,9 +962,9 @@ impl Document {
 				toggle_angle,
 			} => {
 				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_vector_shape_mut() {
-					for anchor in shape.selected_anchors_any_points_mut() {
-						anchor.toggle_mirroring(toggle_distance, toggle_angle);
+				if let Some(shape) = layer.as_subpath_mut() {
+					for manipulator_group in shape.selected_manipulator_groups_any_points_mut() {
+						manipulator_group.toggle_mirroring(toggle_distance, toggle_angle);
 					}
 				}
 				// This does nothing visually so we don't need to send any messages
diff --git a/graphene/src/intersection.rs b/graphene/src/intersection.rs
index b2dfdaf4..ffc56245 100644
--- a/graphene/src/intersection.rs
+++ b/graphene/src/intersection.rs
@@ -1,6 +1,6 @@
 use crate::boolean_ops::{split_path_seg, subdivide_path_seg};
 use crate::consts::{F64LOOSE, F64PRECISE};
-use crate::layers::vector::vector_shape::VectorShape;
+use crate::layers::vector::subpath::Subpath;
 
 use glam::{DAffine2, DMat2, DVec2};
 use kurbo::{BezPath, CubicBez, Line, ParamCurve, ParamCurveDeriv, ParamCurveExtrema, PathSeg, Point, QuadBez, Rect, Shape, Vec2};
@@ -39,9 +39,9 @@ impl Quad {
 		path
 	}
 
-	/// Generates a [VectorShape] of the quad
-	pub fn vector_shape(&self) -> VectorShape {
-		VectorShape::from_points(self.0.into_iter(), true)
+	/// Generates a [subpath] of the quad
+	pub fn subpath(&self) -> Subpath {
+		Subpath::from_points(self.0.into_iter(), true)
 	}
 
 	/// Generates the axis aligned bounding box of the quad
diff --git a/graphene/src/layers/id_vec.rs b/graphene/src/layers/id_vec.rs
index 4306517a..cb0715ea 100644
--- a/graphene/src/layers/id_vec.rs
+++ b/graphene/src/layers/id_vec.rs
@@ -10,7 +10,7 @@ use std::ops::{Deref, DerefMut};
 /// - Access data by providing Unique ID.
 /// - Maintain ordering among the elements.
 /// - Remove elements without changing Unique IDs.
-/// This data structure is somewhat similar to a linked list in terms of invarients.
+/// This data structure is somewhat similar to a linked list in terms of invariants.
 /// The downside is that currently it requires a lot of iteration.
 
 type ElementId = u64;
@@ -54,7 +54,7 @@ impl<T> IdBackedVec<T> {
 	}
 
 	/// Push an element to the end of the vector
-	/// Overriden from Vec, so adding values without creating an id cannot occur
+	/// Overridden from Vec, so adding values without creating an id cannot occur
 	pub fn push(&mut self, element: T) -> Option<ElementId> {
 		self.push_end(element)
 	}
diff --git a/graphene/src/layers/layer_info.rs b/graphene/src/layers/layer_info.rs
index 6bda061b..19cc76cc 100644
--- a/graphene/src/layers/layer_info.rs
+++ b/graphene/src/layers/layer_info.rs
@@ -4,7 +4,7 @@ use super::image_layer::ImageLayer;
 use super::shape_layer::ShapeLayer;
 use super::style::{PathStyle, RenderData};
 use super::text_layer::TextLayer;
-use super::vector::vector_shape::VectorShape;
+use super::vector::subpath::Subpath;
 use crate::intersection::Quad;
 use crate::layers::text_layer::FontCache;
 use crate::DocumentError;
@@ -333,26 +333,26 @@ impl Layer {
 	///
 	/// // Apply the Identity transform, which leaves the points unchanged
 	/// assert_eq!(
-	///     layer.aabounding_box_for_transform(DAffine2::IDENTITY, &Default::default()),
+	///     layer.aabb_for_transform(DAffine2::IDENTITY, &Default::default()),
 	///     Some([DVec2::ZERO, DVec2::ONE]),
 	/// );
 	///
 	/// // Apply a transform that scales every point by a factor of two
 	/// let transform = DAffine2::from_scale(DVec2::ONE * 2.);
 	/// assert_eq!(
-	///     layer.aabounding_box_for_transform(transform, &Default::default()),
+	///     layer.aabb_for_transform(transform, &Default::default()),
 	///     Some([DVec2::ZERO, DVec2::ONE * 2.]),
 	/// );
-	pub fn aabounding_box_for_transform(&self, transform: DAffine2, font_cache: &FontCache) -> Option<[DVec2; 2]> {
+	pub fn aabb_for_transform(&self, transform: DAffine2, font_cache: &FontCache) -> Option<[DVec2; 2]> {
 		self.data.bounding_box(transform, font_cache)
 	}
 
-	pub fn aabounding_box(&self, font_cache: &FontCache) -> Option<[DVec2; 2]> {
-		self.aabounding_box_for_transform(self.transform, font_cache)
+	pub fn aabb(&self, font_cache: &FontCache) -> Option<[DVec2; 2]> {
+		self.aabb_for_transform(self.transform, font_cache)
 	}
 
 	pub fn bounding_transform(&self, font_cache: &FontCache) -> DAffine2 {
-		let scale = match self.aabounding_box_for_transform(DAffine2::IDENTITY, font_cache) {
+		let scale = match self.aabb_for_transform(DAffine2::IDENTITY, font_cache) {
 			Some([a, b]) => {
 				let dimensions = b - a;
 				DAffine2::from_scale(dimensions)
@@ -372,21 +372,21 @@ impl Layer {
 		}
 	}
 
-	pub fn as_vector_shape(&self) -> Option<&VectorShape> {
+	pub fn as_subpath(&self) -> Option<&Subpath> {
 		match &self.data {
 			LayerDataType::Shape(s) => Some(&s.shape),
 			_ => None,
 		}
 	}
 
-	pub fn as_vector_shape_copy(&self) -> Option<VectorShape> {
+	pub fn as_subpath_copy(&self) -> Option<Subpath> {
 		match &self.data {
 			LayerDataType::Shape(s) => Some(s.shape.clone()),
 			_ => None,
 		}
 	}
 
-	pub fn as_vector_shape_mut(&mut self) -> Option<&mut VectorShape> {
+	pub fn as_subpath_mut(&mut self) -> Option<&mut Subpath> {
 		match &mut self.data {
 			LayerDataType::Shape(s) => Some(&mut s.shape),
 			_ => None,
diff --git a/graphene/src/layers/shape_layer.rs b/graphene/src/layers/shape_layer.rs
index 7b41703c..9e9acd59 100644
--- a/graphene/src/layers/shape_layer.rs
+++ b/graphene/src/layers/shape_layer.rs
@@ -1,6 +1,6 @@
 use super::layer_info::LayerData;
 use super::style::{self, PathStyle, RenderData, ViewMode};
-use super::vector::vector_shape::VectorShape;
+use super::vector::subpath::Subpath;
 use crate::intersection::{intersect_quad_bez_path, Quad};
 use crate::layers::text_layer::FontCache;
 use crate::LayerId;
@@ -18,7 +18,7 @@ use std::fmt::Write;
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 pub struct ShapeLayer {
 	/// The geometry of the layer.
-	pub shape: VectorShape,
+	pub shape: Subpath,
 	/// The visual style of the shape.
 	pub style: style::PathStyle,
 	// TODO: We might be able to remove this in a future refactor
@@ -27,9 +27,9 @@ pub struct ShapeLayer {
 
 impl LayerData for ShapeLayer {
 	fn render(&mut self, svg: &mut String, svg_defs: &mut String, transforms: &mut Vec<DAffine2>, render_data: RenderData) {
-		let mut vector_shape = self.shape.clone();
+		let mut subpath = self.shape.clone();
 
-		let kurbo::Rect { x0, y0, x1, y1 } = vector_shape.bounding_box();
+		let kurbo::Rect { x0, y0, x1, y1 } = subpath.bounding_box();
 		let layer_bounds = [(x0, y0).into(), (x1, y1).into()];
 
 		let transform = self.transform(transforms, render_data.view_mode);
@@ -38,9 +38,9 @@ impl LayerData for ShapeLayer {
 			let _ = write!(svg, "<!-- SVG shape has an invalid transform -->");
 			return;
 		}
-		vector_shape.apply_affine(transform);
+		subpath.apply_affine(transform);
 
-		let kurbo::Rect { x0, y0, x1, y1 } = vector_shape.bounding_box();
+		let kurbo::Rect { x0, y0, x1, y1 } = subpath.bounding_box();
 		let transformed_bounds = [(x0, y0).into(), (x1, y1).into()];
 
 		let _ = writeln!(svg, r#"<g transform="matrix("#);
@@ -51,25 +51,25 @@ impl LayerData for ShapeLayer {
 		let _ = write!(
 			svg,
 			r#"<path d="{}" {} />"#,
-			vector_shape.to_svg(),
+			subpath.to_svg(),
 			self.style.render(render_data.view_mode, svg_defs, transform, layer_bounds, transformed_bounds)
 		);
 		let _ = svg.write_str("</g>");
 	}
 
 	fn bounding_box(&self, transform: glam::DAffine2, _font_cache: &FontCache) -> Option<[DVec2; 2]> {
-		let mut vector_shape = self.shape.clone();
+		let mut subpath = self.shape.clone();
 		if transform.matrix2 == DMat2::ZERO {
 			return None;
 		}
-		vector_shape.apply_affine(transform);
+		subpath.apply_affine(transform);
 
-		let kurbo::Rect { x0, y0, x1, y1 } = vector_shape.bounding_box();
+		let kurbo::Rect { x0, y0, x1, y1 } = subpath.bounding_box();
 		Some([(x0, y0).into(), (x1, y1).into()])
 	}
 
 	fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>, _font_cache: &FontCache) {
-		let filled = self.style.fill().is_some() || self.shape.anchors().last().filter(|anchor| anchor.is_close()).is_some();
+		let filled = self.style.fill().is_some() || self.shape.manipulator_groups().last().filter(|manipulator_group| manipulator_group.is_close()).is_some();
 		if intersect_quad_bez_path(quad, &(&self.shape).into(), filled) {
 			intersections.push(path.clone());
 		}
@@ -77,8 +77,8 @@ impl LayerData for ShapeLayer {
 }
 
 impl ShapeLayer {
-	/// Construct a new [ShapeLayer] with the specified [VectorShape] and [PathStyle]
-	pub fn new(shape: VectorShape, style: PathStyle) -> Self {
+	/// Construct a new [ShapeLayer] with the specified [Subpath] and [PathStyle]
+	pub fn new(shape: Subpath, style: PathStyle) -> Self {
 		Self { shape, style, render_index: 1 }
 	}
 
@@ -122,7 +122,7 @@ impl ShapeLayer {
 		path.close_path();
 
 		Self {
-			shape: VectorShape::new_ngon(DVec2::new(0., 0.), sides.into(), 1.),
+			shape: Subpath::new_ngon(DVec2::new(0., 0.), sides.into(), 1.),
 			style,
 			render_index: 1,
 		}
@@ -131,7 +131,7 @@ impl ShapeLayer {
 	/// Create a rectangular shape.
 	pub fn rectangle(style: PathStyle) -> Self {
 		Self {
-			shape: VectorShape::new_rect(DVec2::new(0., 0.), DVec2::new(1., 1.)),
+			shape: Subpath::new_rect(DVec2::new(0., 0.), DVec2::new(1., 1.)),
 			style,
 			render_index: 1,
 		}
@@ -140,7 +140,7 @@ impl ShapeLayer {
 	/// Create an elliptical shape.
 	pub fn ellipse(style: PathStyle) -> Self {
 		Self {
-			shape: VectorShape::new_ellipse(DVec2::new(0., 0.), DVec2::new(1., 1.)),
+			shape: Subpath::new_ellipse(DVec2::new(0., 0.), DVec2::new(1., 1.)),
 			style,
 			render_index: 1,
 		}
@@ -149,7 +149,7 @@ impl ShapeLayer {
 	/// Create a straight line from (0, 0) to (1, 0).
 	pub fn line(style: PathStyle) -> Self {
 		Self {
-			shape: VectorShape::new_line(DVec2::new(0., 0.), DVec2::new(1., 0.)),
+			shape: Subpath::new_line(DVec2::new(0., 0.), DVec2::new(1., 0.)),
 			style,
 			render_index: 1,
 		}
@@ -158,7 +158,7 @@ impl ShapeLayer {
 	/// Create a polygonal line that visits each provided point.
 	pub fn poly_line(points: Vec<impl Into<glam::DVec2>>, style: PathStyle) -> Self {
 		Self {
-			shape: VectorShape::new_poly_line(points),
+			shape: Subpath::new_poly_line(points),
 			style,
 			render_index: 0,
 		}
@@ -168,7 +168,7 @@ impl ShapeLayer {
 	/// The algorithm used in this implementation is described here: <https://www.particleincell.com/2012/bezier-splines/>
 	pub fn spline(points: Vec<impl Into<glam::DVec2>>, style: PathStyle) -> Self {
 		Self {
-			shape: VectorShape::new_spline(points),
+			shape: Subpath::new_spline(points),
 			style,
 			render_index: 0,
 		}
diff --git a/graphene/src/layers/text_layer.rs b/graphene/src/layers/text_layer.rs
index c717498b..a17937e4 100644
--- a/graphene/src/layers/text_layer.rs
+++ b/graphene/src/layers/text_layer.rs
@@ -1,6 +1,6 @@
 use super::layer_info::LayerData;
 use super::style::{PathStyle, RenderData, ViewMode};
-use super::vector::vector_shape::VectorShape;
+use super::vector::subpath::Subpath;
 use crate::intersection::{intersect_quad_bez_path, Quad};
 use crate::LayerId;
 pub use font_cache::{Font, FontCache};
@@ -29,7 +29,7 @@ pub struct TextLayer {
 	#[serde(skip)]
 	pub editable: bool,
 	#[serde(skip)]
-	pub cached_path: Option<VectorShape>,
+	pub cached_path: Option<Subpath>,
 }
 
 impl LayerData for TextLayer {
@@ -68,7 +68,7 @@ impl LayerData for TextLayer {
 		} else {
 			let buzz_face = self.load_face(render_data.font_cache);
 
-			let mut path = self.to_vector_path(buzz_face);
+			let mut path = self.to_subpath(buzz_face);
 
 			let kurbo::Rect { x0, y0, x1, y1 } = path.bounding_box();
 			let bounds = [(x0, y0).into(), (x1, y1).into()];
@@ -136,10 +136,10 @@ impl TextLayer {
 		new
 	}
 
-	/// Converts to a [VectorShape], populating the cache if necessary.
+	/// Converts to a [Subpath], populating the cache if necessary.
 	#[inline]
-	pub fn to_vector_path(&mut self, buzz_face: Option<Face>) -> VectorShape {
-		if self.cached_path.as_ref().filter(|x| !x.anchors().is_empty()).is_none() {
+	pub fn to_subpath(&mut self, buzz_face: Option<Face>) -> Subpath {
+		if self.cached_path.as_ref().filter(|subpath| !subpath.manipulator_groups().is_empty()).is_none() {
 			let path = self.generate_path(buzz_face);
 			self.cached_path = Some(path.clone());
 			return path;
@@ -147,16 +147,19 @@ impl TextLayer {
 		self.cached_path.clone().unwrap()
 	}
 
-	/// Converts to a [VectorShape], without populating the cache.
+	/// Converts to a [Subpath], without populating the cache.
 	#[inline]
-	pub fn to_vector_path_nonmut(&self, font_cache: &FontCache) -> VectorShape {
+	pub fn to_subpath_nonmut(&self, font_cache: &FontCache) -> Subpath {
 		let buzz_face = self.load_face(font_cache);
 
-		self.cached_path.clone().filter(|x| !x.anchors().is_empty()).unwrap_or_else(|| self.generate_path(buzz_face))
+		self.cached_path
+			.clone()
+			.filter(|subpath| !subpath.manipulator_groups().is_empty())
+			.unwrap_or_else(|| self.generate_path(buzz_face))
 	}
 
 	#[inline]
-	pub fn generate_path(&self, buzz_face: Option<Face>) -> VectorShape {
+	pub fn generate_path(&self, buzz_face: Option<Face>) -> Subpath {
 		to_path::to_path(&self.text, buzz_face, self.size, self.line_width)
 	}
 
diff --git a/graphene/src/layers/text_layer/to_path.rs b/graphene/src/layers/text_layer/to_path.rs
index e8c3e8fb..91b0884e 100644
--- a/graphene/src/layers/text_layer/to_path.rs
+++ b/graphene/src/layers/text_layer/to_path.rs
@@ -1,14 +1,14 @@
-use crate::layers::vector::constants::ControlPointType;
-use crate::layers::vector::vector_anchor::VectorAnchor;
-use crate::layers::vector::vector_control_point::VectorControlPoint;
-use crate::layers::vector::vector_shape::VectorShape;
+use crate::layers::vector::constants::ManipulatorType;
+use crate::layers::vector::manipulator_group::ManipulatorGroup;
+use crate::layers::vector::manipulator_point::ManipulatorPoint;
+use crate::layers::vector::subpath::Subpath;
 
 use glam::DVec2;
 use rustybuzz::{GlyphBuffer, UnicodeBuffer};
 use ttf_parser::{GlyphId, OutlineBuilder};
 
 struct Builder {
-	path: VectorShape,
+	path: Subpath,
 	pos: DVec2,
 	offset: DVec2,
 	ascender: f64,
@@ -24,32 +24,32 @@ impl Builder {
 impl OutlineBuilder for Builder {
 	fn move_to(&mut self, x: f32, y: f32) {
 		let anchor = self.point(x, y);
-		if self.path.anchors().last().filter(|el| el.points.iter().any(Option::is_some)).is_some() {
-			self.path.anchors_mut().push_end(VectorAnchor::closed());
+		if self.path.manipulator_groups().last().filter(|el| el.points.iter().any(Option::is_some)).is_some() {
+			self.path.manipulator_groups_mut().push_end(ManipulatorGroup::closed());
 		}
-		self.path.anchors_mut().push_end(VectorAnchor::new(anchor));
+		self.path.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(anchor));
 	}
 
 	fn line_to(&mut self, x: f32, y: f32) {
 		let anchor = self.point(x, y);
-		self.path.anchors_mut().push_end(VectorAnchor::new(anchor));
+		self.path.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(anchor));
 	}
 
 	fn quad_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32) {
 		let [handle, anchor] = [self.point(x1, y1), self.point(x2, y2)];
-		self.path.anchors_mut().last_mut().unwrap().points[ControlPointType::OutHandle] = Some(VectorControlPoint::new(handle, ControlPointType::OutHandle));
-		self.path.anchors_mut().push_end(VectorAnchor::new(anchor));
+		self.path.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::OutHandle] = Some(ManipulatorPoint::new(handle, ManipulatorType::OutHandle));
+		self.path.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(anchor));
 	}
 
 	fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32) {
 		let [handle1, handle2, anchor] = [self.point(x1, y1), self.point(x2, y2), self.point(x3, y3)];
-		self.path.anchors_mut().last_mut().unwrap().points[ControlPointType::OutHandle] = Some(VectorControlPoint::new(handle1, ControlPointType::OutHandle));
-		self.path.anchors_mut().push_end(VectorAnchor::new(anchor));
-		self.path.anchors_mut().last_mut().unwrap().points[ControlPointType::InHandle] = Some(VectorControlPoint::new(handle2, ControlPointType::InHandle));
+		self.path.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::OutHandle] = Some(ManipulatorPoint::new(handle1, ManipulatorType::OutHandle));
+		self.path.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(anchor));
+		self.path.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::InHandle] = Some(ManipulatorPoint::new(handle2, ManipulatorType::InHandle));
 	}
 
 	fn close(&mut self) {
-		self.path.anchors_mut().push_end(VectorAnchor::closed());
+		self.path.manipulator_groups_mut().push_end(ManipulatorGroup::closed());
 	}
 }
 
@@ -80,17 +80,17 @@ fn wrap_word(line_width: Option<f64>, glyph_buffer: &GlyphBuffer, scale: f64, x_
 	false
 }
 
-pub fn to_path(str: &str, buzz_face: Option<rustybuzz::Face>, font_size: f64, line_width: Option<f64>) -> VectorShape {
+pub fn to_path(str: &str, buzz_face: Option<rustybuzz::Face>, font_size: f64, line_width: Option<f64>) -> Subpath {
 	let buzz_face = match buzz_face {
 		Some(face) => face,
 		// Show blank layer if font has not loaded
-		None => return VectorShape::default(),
+		None => return Subpath::default(),
 	};
 
 	let (scale, line_height, mut buffer) = font_properties(&buzz_face, font_size);
 
 	let mut builder = Builder {
-		path: VectorShape::new(),
+		path: Subpath::new(),
 		pos: DVec2::ZERO,
 		offset: DVec2::ZERO,
 		ascender: (buzz_face.ascender() as f64 / buzz_face.height() as f64) * font_size / scale,
diff --git a/graphene/src/layers/vector/constants.rs b/graphene/src/layers/vector/constants.rs
index b7f14062..4882a09a 100644
--- a/graphene/src/layers/vector/constants.rs
+++ b/graphene/src/layers/vector/constants.rs
@@ -1,47 +1,44 @@
-use std::ops::{Index, IndexMut, Not};
+use std::ops::{Index, IndexMut};
 
 use serde::{Deserialize, Serialize};
 
 #[repr(usize)]
 #[derive(PartialEq, Eq, Clone, Debug, Copy, Serialize, Deserialize)]
-pub enum ControlPointType {
-	Anchor = 0,
-	InHandle = 1,
-	OutHandle = 2,
+pub enum ManipulatorType {
+	Anchor,
+	InHandle,
+	OutHandle,
 }
 
-impl ControlPointType {
-	pub fn from_index(index: usize) -> ControlPointType {
+impl ManipulatorType {
+	pub fn from_index(index: usize) -> ManipulatorType {
 		match index {
-			0 => ControlPointType::Anchor,
-			1 => ControlPointType::InHandle,
-			2 => ControlPointType::OutHandle,
-			_ => ControlPointType::Anchor,
+			0 => ManipulatorType::Anchor,
+			1 => ManipulatorType::InHandle,
+			2 => ManipulatorType::OutHandle,
+			_ => ManipulatorType::Anchor,
 		}
 	}
-}
 
-impl Not for ControlPointType {
-	type Output = Self;
-	fn not(self) -> Self::Output {
+	pub fn opposite_handle(self) -> ManipulatorType {
 		match self {
-			ControlPointType::InHandle => ControlPointType::OutHandle,
-			ControlPointType::OutHandle => ControlPointType::InHandle,
-			_ => ControlPointType::Anchor,
+			ManipulatorType::Anchor => ManipulatorType::Anchor,
+			ManipulatorType::InHandle => ManipulatorType::OutHandle,
+			ManipulatorType::OutHandle => ManipulatorType::InHandle,
 		}
 	}
 }
 
 // Allows us to use ManipulatorType for indexing
-impl<T> Index<ControlPointType> for [T; 3] {
+impl<T> Index<ManipulatorType> for [T; 3] {
 	type Output = T;
-	fn index(&self, mt: ControlPointType) -> &T {
+	fn index(&self, mt: ManipulatorType) -> &T {
 		&self[mt as usize]
 	}
 }
-// Allows us to use ControlPointType for indexing, mutably
-impl<T> IndexMut<ControlPointType> for [T; 3] {
-	fn index_mut(&mut self, mt: ControlPointType) -> &mut T {
+// Allows us to use ManipulatorType for indexing, mutably
+impl<T> IndexMut<ManipulatorType> for [T; 3] {
+	fn index_mut(&mut self, mt: ManipulatorType) -> &mut T {
 		&mut self[mt as usize]
 	}
 }
diff --git a/graphene/src/layers/vector/vector_anchor.rs b/graphene/src/layers/vector/manipulator_group.rs
similarity index 51%
rename from graphene/src/layers/vector/vector_anchor.rs
rename to graphene/src/layers/vector/manipulator_group.rs
index 3e9be5db..c7705c27 100644
--- a/graphene/src/layers/vector/vector_anchor.rs
+++ b/graphene/src/layers/vector/manipulator_group.rs
@@ -1,79 +1,84 @@
 use super::{
-	constants::{ControlPointType, SELECTION_THRESHOLD},
-	vector_control_point::VectorControlPoint,
+	constants::{ManipulatorType, SELECTION_THRESHOLD},
+	manipulator_point::ManipulatorPoint,
 };
 use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
 
-/// Brief overview of VectorAnchor
-///                    VectorAnchor <- Container for the anchor metadata and optional VectorControlPoints
-///                          /
-///            [Option<VectorControlPoint>; 3] <- [0] is the anchor's draggable point (but not metadata), [1] is the InHandle's draggable point, [2] is the OutHandle's draggable point
-///          /              |                      \
-///      "Anchor"        "InHandle"             "OutHandle" <- These are VectorControlPoints and the only editable "primitive"
-
-/// VectorAnchor is used to represent an anchor point + handles on the path that can be moved.
+/// [ManipulatorGroup] is used to represent an anchor point + handles on the path that can be moved.
 /// It contains 0-2 handles that are optionally available.
+///
+/// Overview:
+/// ```text
+///          ManipulatorGroup                <- Container for the anchor metadata and optional ManipulatorPoint
+///                  |
+///    [Option<ManipulatorPoint>; 3]         <- [0] is the anchor's draggable point (but not metadata), [1] is the
+///      /           |           \              InHandle's draggable point, [2] is the OutHandle's draggable point
+///     /            |            \
+/// "Anchor"    "InHandle"    "OutHandle"    <- These are ManipulatorPoints and the only editable "primitive"
+/// ```
 #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, Default)]
-pub struct VectorAnchor {
-	// Editable points for the anchor & handles
-	pub points: [Option<VectorControlPoint>; 3],
+pub struct ManipulatorGroup {
+	/// Editable points for the anchor and handles.
+	pub points: [Option<ManipulatorPoint>; 3],
 
 	#[serde(skip)]
-	// The editor state of the anchor and handles
-	pub editor_state: VectorAnchorState,
+	// TODO: Remove this from Graphene, editor state should be stored in the frontend if possible.
+	/// The editor state of the anchor and handles.
+	pub editor_state: ManipulatorGroupEditorState,
 }
 
-impl VectorAnchor {
-	/// Create a new anchor with the given position
-	pub fn new(anchor_pos: DVec2) -> Self {
+impl ManipulatorGroup {
+	/// Create a new anchor with the given position.
+	pub fn new_with_anchor(anchor_pos: DVec2) -> Self {
 		Self {
 			// An anchor and 2x None's which represent non-existent handles
-			points: [Some(VectorControlPoint::new(anchor_pos, ControlPointType::Anchor)), None, None],
-			editor_state: VectorAnchorState::default(),
+			points: [Some(ManipulatorPoint::new(anchor_pos, ManipulatorType::Anchor)), None, None],
+			editor_state: ManipulatorGroupEditorState::default(),
 		}
 	}
 
-	/// Create a new anchor with the given anchor position and handles
+	/// Create a new anchor with the given anchor position and handles.
 	pub fn new_with_handles(anchor_pos: DVec2, handle_in_pos: Option<DVec2>, handle_out_pos: Option<DVec2>) -> Self {
 		Self {
 			points: match (handle_in_pos, handle_out_pos) {
 				(Some(pos1), Some(pos2)) => [
-					Some(VectorControlPoint::new(anchor_pos, ControlPointType::Anchor)),
-					Some(VectorControlPoint::new(pos1, ControlPointType::InHandle)),
-					Some(VectorControlPoint::new(pos2, ControlPointType::OutHandle)),
+					Some(ManipulatorPoint::new(anchor_pos, ManipulatorType::Anchor)),
+					Some(ManipulatorPoint::new(pos1, ManipulatorType::InHandle)),
+					Some(ManipulatorPoint::new(pos2, ManipulatorType::OutHandle)),
 				],
 				(None, Some(pos2)) => [
-					Some(VectorControlPoint::new(anchor_pos, ControlPointType::Anchor)),
+					Some(ManipulatorPoint::new(anchor_pos, ManipulatorType::Anchor)),
 					None,
-					Some(VectorControlPoint::new(pos2, ControlPointType::OutHandle)),
+					Some(ManipulatorPoint::new(pos2, ManipulatorType::OutHandle)),
 				],
 				(Some(pos1), None) => [
-					Some(VectorControlPoint::new(anchor_pos, ControlPointType::Anchor)),
-					Some(VectorControlPoint::new(pos1, ControlPointType::InHandle)),
+					Some(ManipulatorPoint::new(anchor_pos, ManipulatorType::Anchor)),
+					Some(ManipulatorPoint::new(pos1, ManipulatorType::InHandle)),
 					None,
 				],
-				(None, None) => [Some(VectorControlPoint::new(anchor_pos, ControlPointType::Anchor)), None, None],
+				(None, None) => [Some(ManipulatorPoint::new(anchor_pos, ManipulatorType::Anchor)), None, None],
 			},
-			editor_state: VectorAnchorState::default(),
+			editor_state: ManipulatorGroupEditorState::default(),
 		}
 	}
 
-	/// Create a VectorAnchor that represents a close path signal
+	// TODO Convert into bool in subpath
+	/// Create a [ManipulatorGroup] that represents a close path signal.
 	pub fn closed() -> Self {
 		Self {
-			// An anchor being None indicates a ClosePath (aka a path end)
+			// An anchor (the first element) being `None` indicates a ClosePath (i.e. a path end command)
 			points: [None, None, None],
-			editor_state: VectorAnchorState::default(),
+			editor_state: ManipulatorGroupEditorState::default(),
 		}
 	}
 
-	/// Does this [VectorAnchor] represent a close signal?
+	/// Answers whether this [ManipulatorGroup] represent a close shape command.
 	pub fn is_close(&self) -> bool {
-		self.points[ControlPointType::Anchor].is_none() && self.points[ControlPointType::InHandle].is_none()
+		self.points[ManipulatorType::Anchor].is_none() && self.points[ManipulatorType::InHandle].is_none()
 	}
 
-	/// Finds the closest VectorControlPoint owned by this anchor. This can be the handles or the anchor itself
+	/// Finds the closest [ManipulatorPoint] owned by this [ManipulatorGroup]. This may return the anchor or either handle.
 	pub fn closest_point(&self, transform_space: &DAffine2, target: glam::DVec2) -> usize {
 		let mut closest_index: usize = 0;
 		let mut closest_distance_squared: f64 = f64::MAX; // Not ideal
@@ -89,7 +94,7 @@ impl VectorAnchor {
 		closest_index
 	}
 
-	/// Move the selected points by the provided transform
+	/// Move the selected points by the provided transform.
 	pub fn move_selected_points(&mut self, delta: DVec2, absolute_position: DVec2, viewspace: &DAffine2) {
 		let mirror_angle = self.editor_state.mirror_angle_between_handles;
 		// Invert distance since we want it to start disabled
@@ -97,20 +102,20 @@ impl VectorAnchor {
 
 		// TODO Use an ID as opposed to distance, stopgap for now
 		// Transformed into viewspace so SELECTION_THRESHOLD is in pixels
-		let is_drag_target = |point: &mut VectorControlPoint| -> bool { viewspace.transform_point2(absolute_position).distance(viewspace.transform_point2(point.position)) < SELECTION_THRESHOLD };
+		let is_drag_target = |point: &mut ManipulatorPoint| -> bool { viewspace.transform_point2(absolute_position).distance(viewspace.transform_point2(point.position)) < SELECTION_THRESHOLD };
 
 		// Move the point absolutely or relatively depending on if the point is under the cursor (the last selected point)
-		let move_point = |point: &mut VectorControlPoint, delta: DVec2, absolute_position: DVec2| {
+		let move_point = |point: &mut ManipulatorPoint, delta: DVec2, absolute_position: DVec2| {
 			if is_drag_target(point) {
 				point.position = absolute_position;
 			} else {
 				point.position += delta;
 			}
-			assert!(point.position.is_finite(), "Point is not finite")
+			assert!(point.position.is_finite(), "Point is not finite!")
 		};
 
 		// Find the correctly mirrored handle position based on mirroring settings
-		let move_symmetrical_handle = |position: DVec2, opposing_handle: Option<&mut VectorControlPoint>, center: DVec2| {
+		let move_symmetrical_handle = |position: DVec2, opposing_handle: Option<&mut ManipulatorPoint>, center: DVec2| {
 			// Early out for cases where we can't mirror
 			if !mirror_angle || opposing_handle.is_none() {
 				return;
@@ -122,7 +127,7 @@ impl VectorAnchor {
 
 			if let Some(offset) = (position - center).try_normalize() {
 				opposing_handle.position = center - offset * radius;
-				assert!(opposing_handle.position.is_finite(), "Oposing handle not finite")
+				assert!(opposing_handle.position.is_finite(), "Opposing handle not finite!")
 			}
 		};
 
@@ -131,8 +136,7 @@ impl VectorAnchor {
 			return;
 		}
 
-		// If the anchor is selected ignore any handle mirroring / dragging
-		// Drag all points
+		// If the anchor is selected, ignore any handle mirroring/dragging and drag all points
 		if self.is_anchor_selected() {
 			for point in self.points_mut() {
 				move_point(point, delta, absolute_position);
@@ -140,8 +144,7 @@ impl VectorAnchor {
 			return;
 		}
 
-		// If the anchor isn't selected, but both handles are
-		// Drag only handles
+		// If the anchor isn't selected, but both handles are, drag only handles
 		if self.both_handles_selected() {
 			for point in self.selected_handles_mut() {
 				move_point(point, delta, absolute_position);
@@ -151,7 +154,7 @@ impl VectorAnchor {
 
 		// If the anchor isn't selected, and only one handle is selected
 		// Drag the single handle
-		let reflect_center = self.points[ControlPointType::Anchor].as_ref().unwrap().position;
+		let reflect_center = self.points[ManipulatorType::Anchor].as_ref().unwrap().position;
 		let selected_handle = self.selected_handles_mut().next().unwrap();
 		move_point(selected_handle, delta, absolute_position);
 
@@ -161,7 +164,7 @@ impl VectorAnchor {
 		move_symmetrical_handle(selected_handle.position, opposing_handle, reflect_center);
 	}
 
-	/// Delete any VectorControlPoint that are selected, this includes handles or the anchor
+	/// Delete any [ManipulatorPoint] that are selected, this includes handles or the anchor.
 	pub fn delete_selected(&mut self) {
 		for point_option in self.points.iter_mut() {
 			if let Some(point) = point_option {
@@ -172,12 +175,12 @@ impl VectorAnchor {
 		}
 	}
 
-	/// Returns true if any points in this anchor are selected
+	/// Returns true if any points in this [ManipulatorGroup] are selected.
 	pub fn any_points_selected(&self) -> bool {
-		self.points.iter().flatten().any(|pnt| pnt.editor_state.is_selected)
+		self.points.iter().flatten().any(|point| point.editor_state.is_selected)
 	}
 
-	/// Returns true if the anchor point is selected
+	/// Returns true if the anchor point is selected.
 	pub fn is_anchor_selected(&self) -> bool {
 		if let Some(anchor) = &self.points[0] {
 			anchor.editor_state.is_selected
@@ -186,73 +189,83 @@ impl VectorAnchor {
 		}
 	}
 
-	/// Determines if two handle points are selected
+	/// Determines if the two handle points are selected.
 	pub fn both_handles_selected(&self) -> bool {
 		self.points.iter().skip(1).flatten().filter(|pnt| pnt.editor_state.is_selected).count() == 2
 	}
 
-	/// Set a point to selected by ID
-	pub fn select_point(&mut self, point_id: usize, selected: bool) -> Option<&mut VectorControlPoint> {
+	/// Set a point, given its [ManipulatorType] enum integer ID, to a chosen selected state.
+	pub fn select_point(&mut self, point_id: usize, selected: bool) -> Option<&mut ManipulatorPoint> {
 		if let Some(point) = self.points[point_id].as_mut() {
 			point.set_selected(selected);
 		}
 		self.points[point_id].as_mut()
 	}
 
-	/// Clear the selected points for this anchor
+	/// Clear the selected points for this [ManipulatorGroup].
 	pub fn clear_selected_points(&mut self) {
 		for point in self.points.iter_mut().flatten() {
 			point.set_selected(false);
 		}
 	}
 
-	/// Provides the points in this anchor
-	pub fn points(&self) -> impl Iterator<Item = &VectorControlPoint> {
+	/// Provides the points in this [ManipulatorGroup].
+	pub fn points(&self) -> impl Iterator<Item = &ManipulatorPoint> {
 		self.points.iter().flatten()
 	}
 
-	/// Provides the points in this anchor
-	pub fn points_mut(&mut self) -> impl Iterator<Item = &mut VectorControlPoint> {
+	/// Provides the points in this [ManipulatorGroup] as mutable.
+	pub fn points_mut(&mut self) -> impl Iterator<Item = &mut ManipulatorPoint> {
 		self.points.iter_mut().flatten()
 	}
 
-	/// Provides the selected points in this anchor
-	pub fn selected_points(&self) -> impl Iterator<Item = &VectorControlPoint> {
+	/// Provides the selected points in this [ManipulatorGroup].
+	pub fn selected_points(&self) -> impl Iterator<Item = &ManipulatorPoint> {
 		self.points.iter().flatten().filter(|pnt| pnt.editor_state.is_selected)
 	}
 
-	/// Provides mutable selected points in this anchor
-	pub fn selected_points_mut(&mut self) -> impl Iterator<Item = &mut VectorControlPoint> {
+	/// Provides mutable selected points in this [ManipulatorGroup].
+	pub fn selected_points_mut(&mut self) -> impl Iterator<Item = &mut ManipulatorPoint> {
 		self.points.iter_mut().flatten().filter(|pnt| pnt.editor_state.is_selected)
 	}
 
-	/// Provides the selected handles attached to this anchor
-	pub fn selected_handles(&self) -> impl Iterator<Item = &VectorControlPoint> {
+	/// Provides the selected handles attached to this [ManipulatorGroup].
+	pub fn selected_handles(&self) -> impl Iterator<Item = &ManipulatorPoint> {
 		self.points.iter().skip(1).flatten().filter(|pnt| pnt.editor_state.is_selected)
 	}
 
-	/// Provides the mutable selected handles attached to this anchor
-	pub fn selected_handles_mut(&mut self) -> impl Iterator<Item = &mut VectorControlPoint> {
+	/// Provides the mutable selected handles attached to this [ManipulatorGroup].
+	pub fn selected_handles_mut(&mut self) -> impl Iterator<Item = &mut ManipulatorPoint> {
 		self.points.iter_mut().skip(1).flatten().filter(|pnt| pnt.editor_state.is_selected)
 	}
 
-	/// Angle between handles in radians
+	/// Angle between handles, in radians.
 	pub fn angle_between_handles(&self) -> f64 {
 		if let [Some(a1), Some(h1), Some(h2)] = &self.points {
-			return (a1.position - h1.position).angle_between(a1.position - h2.position);
+			(a1.position - h1.position).angle_between(a1.position - h2.position)
+		} else {
+			0.
 		}
-		0.0
 	}
 
-	/// Returns the opposing handle to the handle provided
-	/// Returns the anchor handle if the anchor is provided
-	pub fn opposing_handle(&self, handle: &VectorControlPoint) -> Option<&VectorControlPoint> {
-		self.points[!handle.manipulator_type].as_ref()
+	/// Returns the opposing handle to the handle provided.
+	/// Returns [None] if the provided handle is of type [ManipulatorType::Anchor].
+	/// Returns [None] if the opposing handle doesn't exist.
+	pub fn opposing_handle(&self, handle: &ManipulatorPoint) -> Option<&ManipulatorPoint> {
+		if handle.manipulator_type == ManipulatorType::Anchor {
+			return None;
+		}
+		self.points[handle.manipulator_type.opposite_handle()].as_ref()
 	}
-	/// Returns the opposing handle to the handle provided, mutable
-	/// Returns the anchor handle if the anchor is provided, mutable
-	pub fn opposing_handle_mut(&mut self, handle: &VectorControlPoint) -> Option<&mut VectorControlPoint> {
-		self.points[!handle.manipulator_type].as_mut()
+
+	/// Returns the opposing handle to the handle provided, mutable.
+	/// Returns [None] if the provided handle is of type [ManipulatorType::Anchor].
+	/// Returns [None] if the opposing handle doesn't exist.
+	pub fn opposing_handle_mut(&mut self, handle: &ManipulatorPoint) -> Option<&mut ManipulatorPoint> {
+		if handle.manipulator_type == ManipulatorType::Anchor {
+			return None;
+		}
+		self.points[handle.manipulator_type.opposite_handle()].as_mut()
 	}
 
 	/// Set the mirroring state
@@ -265,13 +278,13 @@ impl VectorAnchor {
 		}
 	}
 
-	/// Helper function to more easily set position of VectorControlPoints
+	/// Helper function to more easily set position of [ManipulatorPoints]
 	pub fn set_point_position(&mut self, point_index: usize, position: DVec2) {
 		assert!(position.is_finite(), "Tried to set_point_position to non finite");
 		if let Some(point) = &mut self.points[point_index] {
 			point.position = position;
 		} else {
-			self.points[point_index] = Some(VectorControlPoint::new(position, ControlPointType::from_index(point_index)))
+			self.points[point_index] = Some(ManipulatorPoint::new(position, ManipulatorType::from_index(point_index)))
 		}
 	}
 
@@ -284,14 +297,14 @@ impl VectorAnchor {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct VectorAnchorState {
-	// If we should maintain the angle between the handles
+pub struct ManipulatorGroupEditorState {
+	// Whether the angle between the handles should be maintained
 	pub mirror_angle_between_handles: bool,
-	// If we should make the handles equidistance from the anchor?
+	// Whether the distance between the handles should be equidistant to the anchor
 	pub mirror_distance_between_handles: bool,
 }
 
-impl Default for VectorAnchorState {
+impl Default for ManipulatorGroupEditorState {
 	fn default() -> Self {
 		Self {
 			mirror_angle_between_handles: true,
diff --git a/graphene/src/layers/vector/vector_control_point.rs b/graphene/src/layers/vector/manipulator_point.rs
similarity index 55%
rename from graphene/src/layers/vector/vector_control_point.rs
rename to graphene/src/layers/vector/manipulator_point.rs
index 41414c76..3f1e7fcd 100644
--- a/graphene/src/layers/vector/vector_control_point.rs
+++ b/graphene/src/layers/vector/manipulator_point.rs
@@ -1,46 +1,48 @@
-use super::constants::ControlPointType;
+use super::constants::ManipulatorType;
 use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
 
-/// VectorControlPoint represents any editable point, anchor or handle
+/// [ManipulatorPoint] represents any editable Bezier point, either an anchor or handle
 #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
-pub struct VectorControlPoint {
+pub struct ManipulatorPoint {
 	/// The sibling element if this is a handle
 	pub position: glam::DVec2,
 	/// The type of manipulator this point is
-	pub manipulator_type: ControlPointType,
+	pub manipulator_type: ManipulatorType,
 
 	#[serde(skip)]
 	/// The state specific to the editor
-	pub editor_state: VectorControlPointState,
+	// TODO Remove this from Graphene, editor state should be stored in the frontend if possible.
+	pub editor_state: ManipulatorPointEditorState,
 }
 
-impl Default for VectorControlPoint {
+impl Default for ManipulatorPoint {
 	fn default() -> Self {
 		Self {
 			position: DVec2::ZERO,
-			manipulator_type: ControlPointType::Anchor,
-			editor_state: VectorControlPointState::default(),
+			manipulator_type: ManipulatorType::Anchor,
+			editor_state: ManipulatorPointEditorState::default(),
 		}
 	}
 }
 
-impl VectorControlPoint {
-	/// Initialize a new control point
-	pub fn new(position: glam::DVec2, manipulator_type: ControlPointType) -> Self {
+impl ManipulatorPoint {
+	/// Initialize a new [ManipulatorPoint].
+	pub fn new(position: glam::DVec2, manipulator_type: ManipulatorType) -> Self {
 		assert!(position.is_finite(), "tried to create point with non finite position");
 		Self {
 			position,
 			manipulator_type,
-			editor_state: VectorControlPointState::default(),
+			editor_state: ManipulatorPointEditorState::default(),
 		}
 	}
 
-	/// Sets if this point is selected
+	/// Sets this [ManipulatorPoint] to a chosen selection state.
 	pub fn set_selected(&mut self, selected: bool) {
 		self.editor_state.is_selected = selected;
 	}
 
+	/// Whether this [ManipulatorPoint] is currently selected.
 	pub fn is_selected(&self) -> bool {
 		self.editor_state.is_selected
 	}
@@ -59,14 +61,14 @@ impl VectorControlPoint {
 }
 
 #[derive(PartialEq, Eq, Clone, Debug)]
-pub struct VectorControlPointState {
-	/// If this control point can be selected
+pub struct ManipulatorPointEditorState {
+	/// Whether or not this manipulator point can be selected.
 	pub can_be_selected: bool,
-	/// Is this control point currently selected
+	/// Whether or not this manipulator point is currently selected.
 	pub is_selected: bool,
 }
 
-impl Default for VectorControlPointState {
+impl Default for ManipulatorPointEditorState {
 	fn default() -> Self {
 		Self {
 			can_be_selected: true,
diff --git a/graphene/src/layers/vector/mod.rs b/graphene/src/layers/vector/mod.rs
index e87d4866..65a855f4 100644
--- a/graphene/src/layers/vector/mod.rs
+++ b/graphene/src/layers/vector/mod.rs
@@ -1,4 +1,4 @@
 pub mod constants;
-pub mod vector_anchor;
-pub mod vector_control_point;
-pub mod vector_shape;
+pub mod manipulator_group;
+pub mod manipulator_point;
+pub mod subpath;
diff --git a/graphene/src/layers/vector/subpath.rs b/graphene/src/layers/vector/subpath.rs
new file mode 100644
index 00000000..52a38242
--- /dev/null
+++ b/graphene/src/layers/vector/subpath.rs
@@ -0,0 +1,541 @@
+use super::constants::ManipulatorType;
+use super::manipulator_group::ManipulatorGroup;
+use super::manipulator_point::ManipulatorPoint;
+use crate::layers::id_vec::IdBackedVec;
+use crate::layers::layer_info::{Layer, LayerDataType};
+
+use glam::{DAffine2, DVec2};
+use kurbo::{BezPath, PathEl, Rect, Shape};
+use serde::{Deserialize, Serialize};
+
+/// [Subpath] represents a single vector path, containing many [ManipulatorGroups].
+/// For each closed shape we keep a [Subpath] which contains the [ManipulatorGroup]s (handles and anchors) that define that shape.
+// TODO Add "closed" bool to subpath
+#[derive(PartialEq, Clone, Debug, Default, Serialize, Deserialize)]
+pub struct Subpath(IdBackedVec<ManipulatorGroup>);
+
+impl Subpath {
+	// ** INITIALIZATION **
+
+	/// Create a new [Subpath] with no [ManipulatorGroup]s.
+	pub fn new() -> Self {
+		Subpath { ..Default::default() }
+	}
+
+	/// Construct a [Subpath] from a point iterator
+	pub fn from_points(points: impl Iterator<Item = DVec2>, closed: bool) -> Self {
+		let manipulator_groups = points.map(ManipulatorGroup::new_with_anchor);
+
+		let mut p_line = Subpath(IdBackedVec::default());
+
+		p_line.0.push_range(manipulator_groups);
+		if closed {
+			p_line.0.push(ManipulatorGroup::closed());
+		}
+
+		p_line
+	}
+
+	/// Create a new [Subpath] from a [kurbo Shape](Shape).
+	/// This exists to smooth the transition away from Kurbo
+	pub fn from_kurbo_shape<T: Shape>(shape: &T) -> Self {
+		shape.path_elements(0.1).into()
+	}
+
+	// ** PRIMITIVE CONSTRUCTION **
+
+	/// constructs a rectangle with `p1` as the lower left and `p2` as the top right
+	pub fn new_rect(p1: DVec2, p2: DVec2) -> Self {
+		Subpath(
+			vec![
+				ManipulatorGroup::new_with_anchor(p1),
+				ManipulatorGroup::new_with_anchor(DVec2::new(p1.x, p2.y)),
+				ManipulatorGroup::new_with_anchor(p2),
+				ManipulatorGroup::new_with_anchor(DVec2::new(p2.x, p1.y)),
+				ManipulatorGroup::closed(),
+			]
+			.into_iter()
+			.collect(),
+		)
+	}
+
+	pub fn new_ellipse(p1: DVec2, p2: DVec2) -> Self {
+		let x_height = DVec2::new((p2.x - p1.x).abs(), 0.);
+		let y_height = DVec2::new(0., (p2.y - p1.y).abs());
+		let center = (p1 + p2) * 0.5;
+		let top = center + y_height * 0.5;
+		let bottom = center - y_height * 0.5;
+		let left = center + x_height * 0.5;
+		let right = center - x_height * 0.5;
+
+		// Constant explained here https://stackoverflow.com/a/27863181
+		let curve_constant = 0.55228_3;
+		let handle_offset_x = x_height * curve_constant * 0.5;
+		let handle_offset_y = y_height * curve_constant * 0.5;
+
+		Subpath(
+			vec![
+				ManipulatorGroup::new_with_handles(top, Some(top + handle_offset_x), Some(top - handle_offset_x)),
+				ManipulatorGroup::new_with_handles(right, Some(right + handle_offset_y), Some(right - handle_offset_y)),
+				ManipulatorGroup::new_with_handles(bottom, Some(bottom - handle_offset_x), Some(bottom + handle_offset_x)),
+				ManipulatorGroup::new_with_handles(left, Some(left - handle_offset_y), Some(left + handle_offset_y)),
+				ManipulatorGroup::closed(),
+			]
+			.into_iter()
+			.collect(),
+		)
+	}
+
+	/// constructs an ngon
+	/// `radius` is the distance from the `center` to any vertex, or the radius of the circle the ngon may be inscribed inside
+	/// `sides` is the number of sides
+	pub fn new_ngon(center: DVec2, sides: u64, radius: f64) -> Self {
+		let mut manipulator_groups = vec![];
+		for i in 0..sides {
+			let angle = (i as f64) * std::f64::consts::TAU / (sides as f64);
+			let center = center + DVec2::ONE * radius;
+			let position = ManipulatorGroup::new_with_anchor(DVec2::new(center.x + radius * f64::cos(angle), center.y + radius * f64::sin(angle)) * 0.5);
+
+			manipulator_groups.push(position);
+		}
+		manipulator_groups.push(ManipulatorGroup::closed());
+
+		Subpath(manipulator_groups.into_iter().collect())
+	}
+
+	/// Constructs a line from `p1` to `p2`
+	pub fn new_line(p1: DVec2, p2: DVec2) -> Self {
+		Subpath(vec![ManipulatorGroup::new_with_anchor(p1), ManipulatorGroup::new_with_anchor(p2)].into_iter().collect())
+	}
+
+	/// Constructs a set of lines from `p1` to `pN`
+	pub fn new_poly_line<T: Into<glam::DVec2>>(points: Vec<T>) -> Self {
+		let manipulator_groups = points.into_iter().map(|point| ManipulatorGroup::new_with_anchor(point.into()));
+		let mut p_line = Subpath(IdBackedVec::default());
+		p_line.0.push_range(manipulator_groups);
+		p_line
+	}
+
+	pub fn new_spline<T: Into<glam::DVec2>>(points: Vec<T>) -> Self {
+		let mut new = Self::default();
+		// shadow `points`
+		let points: Vec<DVec2> = points.into_iter().map(Into::<glam::DVec2>::into).collect();
+
+		// Number of points = number of points to find handles for
+		let n = points.len();
+
+		// matrix coefficients a, b and c (see https://mathworld.wolfram.com/CubicSpline.html)
+		// because the 'a' coefficients are all 1 they need not be stored
+		// this algorithm does a variation of the above algorithm.
+		// Instead of using the traditional cubic: a + bt + ct^2 + dt^3, we use the bezier cubic.
+
+		let mut b = vec![DVec2::new(4.0, 4.0); n];
+		b[0] = DVec2::new(2.0, 2.0);
+		b[n - 1] = DVec2::new(2.0, 2.0);
+
+		let mut c = vec![DVec2::new(1.0, 1.0); n];
+
+		// 'd' is the the second point in a cubic bezier, which is what we solve for
+		let mut d = vec![DVec2::ZERO; n];
+
+		d[0] = DVec2::new(2.0 * points[1].x + points[0].x, 2.0 * points[1].y + points[0].y);
+		d[n - 1] = DVec2::new(3.0 * points[n - 1].x, 3.0 * points[n - 1].y);
+		for idx in 1..(n - 1) {
+			d[idx] = DVec2::new(4.0 * points[idx].x + 2.0 * points[idx + 1].x, 4.0 * points[idx].y + 2.0 * points[idx + 1].y);
+		}
+
+		// Solve with Thomas algorithm (see https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm)
+		// do row operations to eliminate `a` coefficients
+		c[0] /= -b[0];
+		d[0] /= -b[0];
+		for i in 1..n {
+			b[i] += c[i - 1];
+			// for some reason the below line makes the borrow checker mad
+			//d[i] += d[i-1]
+			d[i] = d[i] + d[i - 1];
+			c[i] /= -b[i];
+			d[i] /= -b[i];
+		}
+
+		// at this point b[i] == -a[i + 1], a[i] == 0,
+		// do row operations to eliminate 'c' coefficients and solve
+		d[n - 1] *= -1.0;
+		for i in (0..n - 1).rev() {
+			d[i] = d[i] - (c[i] * d[i + 1]);
+			d[i] *= -1.0; //d[i] /= b[i]
+		}
+
+		// given the second point in the n'th cubic bezier, the third point is given by 2 * points[n+1] - b[n+1].
+		// to find 'handle1_pos' for the n'th point we need the n-1 cubic bezier
+		new.0.push_end(ManipulatorGroup::new_with_handles(points[0], None, Some(d[0])));
+		for i in 1..n - 1 {
+			new.0.push_end(ManipulatorGroup::new_with_handles(points[i], Some(2.0 * points[i] - d[i]), Some(d[i])));
+		}
+		new.0.push_end(ManipulatorGroup::new_with_handles(points[n - 1], Some(2.0 * points[n - 1] - d[n - 1]), None));
+
+		new
+	}
+
+	/// Move the selected points by the delta vector
+	pub fn move_selected(&mut self, delta: DVec2, absolute_position: DVec2, viewspace: &DAffine2) {
+		self.selected_manipulator_groups_any_points_mut()
+			.for_each(|manipulator_group| manipulator_group.move_selected_points(delta, absolute_position, viewspace));
+	}
+
+	/// Delete the selected points from the [Subpath]
+	pub fn delete_selected(&mut self) {
+		let mut ids_to_delete: Vec<u64> = vec![];
+		for (id, manipulator_group) in self.manipulator_groups_mut().enumerate_mut() {
+			if manipulator_group.is_anchor_selected() {
+				ids_to_delete.push(*id);
+			} else {
+				manipulator_group.delete_selected();
+			}
+		}
+
+		for id in ids_to_delete {
+			self.manipulator_groups_mut().remove(id);
+		}
+	}
+
+	// Apply a transformation to all of the Subpath points
+	pub fn apply_affine(&mut self, affine: DAffine2) {
+		for manipulator_group in self.manipulator_groups_mut().iter_mut() {
+			manipulator_group.transform(&affine);
+		}
+	}
+
+	// ** SELECTION OF POINTS **
+
+	/// Set a single point to a chosen selection state by providing `(manipulator group ID, manipulator type)`.
+	pub fn select_point(&mut self, point: (u64, ManipulatorType), selected: bool) -> Option<&mut ManipulatorGroup> {
+		let (manipulator_group_id, point_id) = point;
+		if let Some(manipulator_group) = self.manipulator_groups_mut().by_id_mut(manipulator_group_id) {
+			manipulator_group.select_point(point_id as usize, selected);
+
+			Some(manipulator_group)
+		} else {
+			None
+		}
+	}
+
+	/// Set points in the [Subpath] to a chosen selection state, given by `(manipulator group ID, manipulator type)`.
+	pub fn select_points(&mut self, points: &[(u64, ManipulatorType)], selected: bool) {
+		points.iter().for_each(|point| {
+			self.select_point(*point, selected);
+		});
+	}
+
+	/// Select all the anchors in this shape
+	pub fn select_all_anchors(&mut self) {
+		for manipulator_group in self.manipulator_groups_mut().iter_mut() {
+			manipulator_group.select_point(ManipulatorType::Anchor as usize, true);
+		}
+	}
+
+	/// Select an anchor by index
+	pub fn select_anchor_by_index(&mut self, manipulator_group_index: usize) -> Option<&mut ManipulatorGroup> {
+		if let Some(manipulator_group) = self.manipulator_groups_mut().by_index_mut(manipulator_group_index) {
+			manipulator_group.select_point(ManipulatorType::Anchor as usize, true);
+
+			Some(manipulator_group)
+		} else {
+			None
+		}
+	}
+
+	/// The last anchor in the shape
+	pub fn select_last_anchor(&mut self) -> Option<&mut ManipulatorGroup> {
+		if let Some(manipulator_group) = self.manipulator_groups_mut().last_mut() {
+			manipulator_group.select_point(ManipulatorType::Anchor as usize, true);
+
+			Some(manipulator_group)
+		} else {
+			None
+		}
+	}
+
+	/// Clear all the selected manipulator groups, i.e., clear the selected points inside the manipulator groups
+	pub fn clear_selected_manipulator_groups(&mut self) {
+		for manipulator_group in self.manipulator_groups_mut().iter_mut() {
+			manipulator_group.clear_selected_points();
+		}
+	}
+
+	// ** ACCESSING MANIPULATORGROUPS **
+
+	/// Return all the selected anchors, reference
+	pub fn selected_manipulator_groups(&self) -> impl Iterator<Item = &ManipulatorGroup> {
+		self.manipulator_groups().iter().filter(|manipulator_group| manipulator_group.is_anchor_selected())
+	}
+
+	/// Return all the selected anchors, mutable
+	pub fn selected_manipulator_groups_mut(&mut self) -> impl Iterator<Item = &mut ManipulatorGroup> {
+		self.manipulator_groups_mut().iter_mut().filter(|manipulator_group| manipulator_group.is_anchor_selected())
+	}
+
+	/// Return all the selected [ManipulatorPoint]s by reference
+	pub fn selected_manipulator_groups_any_points(&self) -> impl Iterator<Item = &ManipulatorGroup> {
+		self.manipulator_groups().iter().filter(|manipulator_group| manipulator_group.any_points_selected())
+	}
+
+	/// Return all the selected [ManipulatorPoint]s by mutable reference
+	pub fn selected_manipulator_groups_any_points_mut(&mut self) -> impl Iterator<Item = &mut ManipulatorGroup> {
+		self.manipulator_groups_mut().iter_mut().filter(|manipulator_group| manipulator_group.any_points_selected())
+	}
+
+	/// An alias for `self.0`
+	pub fn manipulator_groups(&self) -> &IdBackedVec<ManipulatorGroup> {
+		&self.0
+	}
+
+	/// Returns a [ManipulatorPoint] from the last [ManipulatorGroup] in the [Subpath].
+	pub fn last_point(&self, control_type: ManipulatorType) -> Option<&ManipulatorPoint> {
+		self.manipulator_groups().last().and_then(|manipulator_group| manipulator_group.points[control_type].as_ref())
+	}
+
+	/// Returns a [ManipulatorPoint] from the last [ManipulatorGroup], mutably
+	pub fn last_point_mut(&mut self, control_type: ManipulatorType) -> Option<&mut ManipulatorPoint> {
+		self.manipulator_groups_mut().last_mut().and_then(|manipulator_group| manipulator_group.points[control_type].as_mut())
+	}
+
+	/// Returns a [ManipulatorPoint]  from the first [ManipulatorGroup]
+	pub fn first_point(&self, control_type: ManipulatorType) -> Option<&ManipulatorPoint> {
+		self.manipulator_groups().first().and_then(|manipulator_group| manipulator_group.points[control_type].as_ref())
+	}
+
+	/// Returns a [ManipulatorPoint] from the first [ManipulatorGroup]
+	pub fn first_point_mut(&mut self, control_type: ManipulatorType) -> Option<&mut ManipulatorPoint> {
+		self.manipulator_groups_mut().first_mut().and_then(|manipulator_group| manipulator_group.points[control_type].as_mut())
+	}
+
+	/// Should we close the shape?
+	pub fn should_close_shape(&self) -> bool {
+		if self.last_point(ManipulatorType::Anchor).is_none() {
+			return false;
+		}
+
+		self.first_point(ManipulatorType::Anchor)
+			.unwrap()
+			.position
+			.distance(self.last_point(ManipulatorType::Anchor).unwrap().position)
+			< 0.001 // TODO Replace with constant, a small epsilon
+	}
+
+	/// Close the shape if able
+	pub fn close_shape(&mut self) {
+		if self.should_close_shape() {
+			self.manipulator_groups_mut().push_end(ManipulatorGroup::closed());
+		}
+	}
+
+	/// An alias for `self.0` mutable
+	pub fn manipulator_groups_mut(&mut self) -> &mut IdBackedVec<ManipulatorGroup> {
+		&mut self.0
+	}
+
+	// ** INTERFACE WITH KURBO **
+
+	// TODO Implement our own a local bounding box calculation
+	/// Return the bounding box of the shape
+	pub fn bounding_box(&self) -> Rect {
+		<&Self as Into<BezPath>>::into(self).bounding_box()
+	}
+
+	/// Use kurbo to convert this shape into an SVG path
+	pub fn to_svg(&mut self) -> String {
+		fn write_positions(result: &mut String, values: [Option<DVec2>; 3]) {
+			use std::fmt::Write;
+			let count = values.into_iter().flatten().count();
+			for (index, pos) in values.into_iter().flatten().enumerate() {
+				write!(result, "{},{}", pos.x, pos.y).unwrap();
+				if index != count - 1 {
+					result.push(' ');
+				}
+			}
+		}
+
+		let mut result = String::new();
+		// The out position from the previous ManipulatorGroup
+		let mut last_out_handle = None;
+		// The values from the last moveto (for closing the path)
+		let (mut first_in_handle, mut first_in_anchor) = (None, None);
+		// Should the next element be a moveto?
+		let mut start_new_contour = true;
+		for manipulator_group in self.manipulator_groups().iter() {
+			let in_handle = manipulator_group.points[ManipulatorType::InHandle].as_ref().map(|point| point.position);
+			let anchor = manipulator_group.points[ManipulatorType::Anchor].as_ref().map(|point| point.position);
+			let out_handle = manipulator_group.points[ManipulatorType::OutHandle].as_ref().map(|point| point.position);
+
+			let command = match (last_out_handle.is_some(), in_handle.is_some(), anchor.is_some()) {
+				(_, _, true) if start_new_contour => 'M',
+				(true, false, true) | (false, true, true) => 'Q',
+				(true, true, true) => 'C',
+				(false, false, true) => 'L',
+				(_, false, false) => 'Z',
+				_ => panic!("Invalid shape {:#?}", self),
+			};
+
+			// Complete the last curve
+			if command == 'Z' {
+				if last_out_handle.is_some() && first_in_handle.is_some() {
+					result.push('C');
+					write_positions(&mut result, [last_out_handle, first_in_handle, first_in_anchor]);
+				} else if last_out_handle.is_some() || first_in_handle.is_some() {
+					result.push('Q');
+					write_positions(&mut result, [last_out_handle, first_in_handle, first_in_anchor]);
+				} else {
+					result.push('Z');
+				}
+			} else if command == 'M' {
+				// Update the last moveto position
+				(first_in_handle, first_in_anchor) = (in_handle, anchor);
+				result.push(command);
+				write_positions(&mut result, [None, None, anchor]);
+			} else {
+				result.push(command);
+				write_positions(&mut result, [last_out_handle, in_handle, anchor]);
+			}
+			start_new_contour = command == 'Z';
+			last_out_handle = out_handle;
+		}
+		result
+	}
+}
+
+// ** CONVERSIONS **
+
+impl<'a> TryFrom<&'a mut Layer> for &'a mut Subpath {
+	type Error = &'static str;
+	/// Convert a mutable layer into a mutable [Subpath].
+	fn try_from(layer: &'a mut Layer) -> Result<&'a mut Subpath, Self::Error> {
+		match &mut layer.data {
+			LayerDataType::Shape(layer) => Ok(&mut layer.shape),
+			// TODO Resolve converting text into a Subpath at the layer level
+			// LayerDataType::Text(text) => Some(Subpath::new(path_to_shape.to_vec(), viewport_transform, true)),
+			_ => Err("Did not find any shape data in the layer"),
+		}
+	}
+}
+
+impl<'a> TryFrom<&'a Layer> for &'a Subpath {
+	type Error = &'static str;
+	/// Convert a reference to a layer into a reference of a [Subpath].
+	fn try_from(layer: &'a Layer) -> Result<&'a Subpath, Self::Error> {
+		match &layer.data {
+			LayerDataType::Shape(layer) => Ok(&layer.shape),
+			// TODO Resolve converting text into a Subpath at the layer level
+			// LayerDataType::Text(text) => Some(Subpath::new(path_to_shape.to_vec(), viewport_transform, true)),
+			_ => Err("Did not find any shape data in the layer"),
+		}
+	}
+}
+
+impl From<&Subpath> for BezPath {
+	/// Create a [BezPath] from a [Subpath].
+	fn from(subpath: &Subpath) -> Self {
+		// Take manipulator groups and create path elements: line, quad or curve, or a close indicator
+		let manipulator_groups_to_path_el = |first: &ManipulatorGroup, second: &ManipulatorGroup| -> (PathEl, bool) {
+			match [
+				&first.points[ManipulatorType::OutHandle],
+				&second.points[ManipulatorType::InHandle],
+				&second.points[ManipulatorType::Anchor],
+			] {
+				[None, None, Some(anchor)] => (PathEl::LineTo(point_to_kurbo(anchor)), false),
+				[None, Some(in_handle), Some(anchor)] => (PathEl::QuadTo(point_to_kurbo(in_handle), point_to_kurbo(anchor)), false),
+				[Some(out_handle), None, Some(anchor)] => (PathEl::QuadTo(point_to_kurbo(out_handle), point_to_kurbo(anchor)), false),
+				[Some(out_handle), Some(in_handle), Some(anchor)] => (PathEl::CurveTo(point_to_kurbo(out_handle), point_to_kurbo(in_handle), point_to_kurbo(anchor)), false),
+				[Some(out_handle), None, None] => {
+					if let Some(first_anchor) = subpath.manipulator_groups().first() {
+						(
+							if let Some(in_handle) = &first_anchor.points[ManipulatorType::InHandle] {
+								PathEl::CurveTo(
+									point_to_kurbo(out_handle),
+									point_to_kurbo(in_handle),
+									point_to_kurbo(first_anchor.points[ManipulatorType::Anchor].as_ref().unwrap()),
+								)
+							} else {
+								PathEl::QuadTo(point_to_kurbo(out_handle), point_to_kurbo(first_anchor.points[ManipulatorType::Anchor].as_ref().unwrap()))
+							},
+							true,
+						)
+					} else {
+						(PathEl::ClosePath, true)
+					}
+				}
+				[None, None, None] => (PathEl::ClosePath, true),
+				_ => panic!("Invalid path element {:#?}", subpath),
+			}
+		};
+
+		if subpath.manipulator_groups().is_empty() {
+			return BezPath::new();
+		}
+
+		let mut bez_path = vec![];
+		let mut start_new_shape = true;
+
+		for elements in subpath.manipulator_groups().windows(2) {
+			let first = &elements[0];
+			let second = &elements[1];
+
+			// Tell kurbo cursor to move to the first anchor
+			if start_new_shape {
+				if let Some(anchor) = &first.points[ManipulatorType::Anchor] {
+					bez_path.push(PathEl::MoveTo(point_to_kurbo(anchor)));
+				}
+			}
+
+			// Create a path element from our first and second manipulator groups in the window
+			let (path_el, should_start_new_shape) = manipulator_groups_to_path_el(first, second);
+			start_new_shape = should_start_new_shape;
+			bez_path.push(path_el);
+			if should_start_new_shape && bez_path.last().filter(|&&el| el == PathEl::ClosePath).is_none() {
+				bez_path.push(PathEl::ClosePath)
+			}
+		}
+
+		BezPath::from_vec(bez_path)
+	}
+}
+
+impl<T: Iterator<Item = PathEl>> From<T> for Subpath {
+	/// Create a Subpath from a [BezPath].
+	fn from(path: T) -> Self {
+		let mut subpath = Subpath::new();
+		for path_el in path {
+			match path_el {
+				PathEl::MoveTo(p) => {
+					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p)));
+				}
+				PathEl::LineTo(p) => {
+					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p)));
+				}
+				PathEl::QuadTo(p0, p1) => {
+					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p1)));
+					subpath.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::InHandle] = Some(ManipulatorPoint::new(kurbo_point_to_dvec2(p0), ManipulatorType::InHandle));
+				}
+				PathEl::CurveTo(p0, p1, p2) => {
+					subpath.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::OutHandle] = Some(ManipulatorPoint::new(kurbo_point_to_dvec2(p0), ManipulatorType::OutHandle));
+					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::new_with_anchor(kurbo_point_to_dvec2(p2)));
+					subpath.manipulator_groups_mut().last_mut().unwrap().points[ManipulatorType::InHandle] = Some(ManipulatorPoint::new(kurbo_point_to_dvec2(p1), ManipulatorType::InHandle));
+				}
+				PathEl::ClosePath => {
+					subpath.manipulator_groups_mut().push_end(ManipulatorGroup::closed());
+				}
+			}
+		}
+
+		subpath
+	}
+}
+
+#[inline]
+fn point_to_kurbo(point: &ManipulatorPoint) -> kurbo::Point {
+	kurbo::Point::new(point.position.x, point.position.y)
+}
+
+#[inline]
+fn kurbo_point_to_dvec2(point: kurbo::Point) -> DVec2 {
+	DVec2::new(point.x, point.y)
+}
diff --git a/graphene/src/layers/vector/vector_shape.rs b/graphene/src/layers/vector/vector_shape.rs
deleted file mode 100644
index a3215b72..00000000
--- a/graphene/src/layers/vector/vector_shape.rs
+++ /dev/null
@@ -1,529 +0,0 @@
-use super::constants::ControlPointType;
-use super::vector_anchor::VectorAnchor;
-use super::vector_control_point::VectorControlPoint;
-use crate::layers::id_vec::IdBackedVec;
-use crate::layers::layer_info::{Layer, LayerDataType};
-
-use glam::{DAffine2, DVec2};
-use kurbo::{BezPath, PathEl, Rect, Shape};
-use serde::{Deserialize, Serialize};
-
-/// VectorShape represents a single vector shape, containing many anchors
-/// For each closed shape we keep a VectorShape which contains the handles and anchors that define that shape.
-#[derive(PartialEq, Clone, Debug, Default, Serialize, Deserialize)]
-pub struct VectorShape(IdBackedVec<VectorAnchor>);
-
-impl VectorShape {
-	// ** SHAPE INITIALIZATION **
-
-	/// Create a new VectorShape with no anchors or handles
-	pub fn new() -> Self {
-		VectorShape { ..Default::default() }
-	}
-
-	/// Construct a [VectorShape] from a point iterator
-	pub fn from_points(points: impl Iterator<Item = DVec2>, closed: bool) -> Self {
-		let anchors = points.map(VectorAnchor::new);
-		let mut p_line = VectorShape(IdBackedVec::default());
-		p_line.0.push_range(anchors);
-		if closed {
-			p_line.0.push(VectorAnchor::closed());
-		}
-		p_line
-	}
-
-	/// Create a new VectorShape from a kurbo Shape
-	/// This exists to smooth the transition away from Kurbo
-	pub fn from_kurbo_shape<T: Shape>(shape: &T) -> Self {
-		shape.path_elements(0.1).into()
-	}
-
-	// ** PRIMITIVE CONSTRUCTION **
-
-	/// constructs a rectangle with `p1` as the lower left and `p2` as the top right
-	pub fn new_rect(p1: DVec2, p2: DVec2) -> Self {
-		VectorShape(
-			vec![
-				VectorAnchor::new(p1),
-				VectorAnchor::new(DVec2::new(p1.x, p2.y)),
-				VectorAnchor::new(p2),
-				VectorAnchor::new(DVec2::new(p2.x, p1.y)),
-				VectorAnchor::closed(),
-			]
-			.into_iter()
-			.collect(),
-		)
-	}
-
-	pub fn new_ellipse(p1: DVec2, p2: DVec2) -> Self {
-		let x_height = DVec2::new((p2.x - p1.x).abs(), 0.);
-		let y_height = DVec2::new(0., (p2.y - p1.y).abs());
-		let center = (p1 + p2) * 0.5;
-		let top = center + y_height * 0.5;
-		let bottom = center - y_height * 0.5;
-		let left = center + x_height * 0.5;
-		let right = center - x_height * 0.5;
-
-		// Constant explained here https://stackoverflow.com/a/27863181
-		let curve_constant = 0.55228_3;
-		let handle_offset_x = x_height * curve_constant * 0.5;
-		let handle_offset_y = y_height * curve_constant * 0.5;
-
-		VectorShape(
-			vec![
-				VectorAnchor::new_with_handles(top, Some(top + handle_offset_x), Some(top - handle_offset_x)),
-				VectorAnchor::new_with_handles(right, Some(right + handle_offset_y), Some(right - handle_offset_y)),
-				VectorAnchor::new_with_handles(bottom, Some(bottom - handle_offset_x), Some(bottom + handle_offset_x)),
-				VectorAnchor::new_with_handles(left, Some(left - handle_offset_y), Some(left + handle_offset_y)),
-				VectorAnchor::closed(),
-			]
-			.into_iter()
-			.collect(),
-		)
-	}
-
-	/// constructs an ngon
-	/// `radius` is the distance from the `center` to any vertex, or the radius of the circle the ngon may be inscribed inside
-	/// `sides` is the number of sides
-	pub fn new_ngon(center: DVec2, sides: u64, radius: f64) -> Self {
-		let mut anchors = vec![];
-		for i in 0..sides {
-			let angle = (i as f64) * std::f64::consts::TAU / (sides as f64);
-			let center = center + DVec2::ONE * radius;
-			let position = VectorAnchor::new(DVec2::new(center.x + radius * f64::cos(angle), center.y + radius * f64::sin(angle)) * 0.5);
-			anchors.push(position);
-		}
-		anchors.push(VectorAnchor::closed());
-		VectorShape(anchors.into_iter().collect())
-	}
-
-	/// Constructs a line from `p1` to `p2`
-	pub fn new_line(p1: DVec2, p2: DVec2) -> Self {
-		VectorShape(vec![VectorAnchor::new(p1), VectorAnchor::new(p2)].into_iter().collect())
-	}
-
-	/// Constructs a set of lines from `p1` to `pN`
-	pub fn new_poly_line<T: Into<glam::DVec2>>(points: Vec<T>) -> Self {
-		let anchors = points.into_iter().map(|point| VectorAnchor::new(point.into()));
-		let mut p_line = VectorShape(IdBackedVec::default());
-		p_line.0.push_range(anchors);
-		p_line
-	}
-
-	pub fn new_spline<T: Into<glam::DVec2>>(points: Vec<T>) -> Self {
-		let mut new = Self::default();
-		// shadow `points`
-		let points: Vec<DVec2> = points.into_iter().map(Into::<glam::DVec2>::into).collect();
-
-		// Number of points = number of points to find handles for
-		let n = points.len();
-
-		// matrix coefficients a, b and c (see https://mathworld.wolfram.com/CubicSpline.html)
-		// because the 'a' coefficients are all 1 they need not be stored
-		// this algorithm does a variation of the above algorithm.
-		// Instead of using the traditional cubic: a + bt + ct^2 + dt^3, we use the bezier cubic.
-
-		let mut b = vec![DVec2::new(4.0, 4.0); n];
-		b[0] = DVec2::new(2.0, 2.0);
-		b[n - 1] = DVec2::new(2.0, 2.0);
-
-		let mut c = vec![DVec2::new(1.0, 1.0); n];
-
-		// 'd' is the the second point in a cubic bezier, which is what we solve for
-		let mut d = vec![DVec2::ZERO; n];
-
-		d[0] = DVec2::new(2.0 * points[1].x + points[0].x, 2.0 * points[1].y + points[0].y);
-		d[n - 1] = DVec2::new(3.0 * points[n - 1].x, 3.0 * points[n - 1].y);
-		for idx in 1..(n - 1) {
-			d[idx] = DVec2::new(4.0 * points[idx].x + 2.0 * points[idx + 1].x, 4.0 * points[idx].y + 2.0 * points[idx + 1].y);
-		}
-
-		// Solve with Thomas algorithm (see https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm)
-		// do row operations to eliminate `a` coefficients
-		c[0] /= -b[0];
-		d[0] /= -b[0];
-		for i in 1..n {
-			b[i] += c[i - 1];
-			// for some reason the below line makes the borrow checker mad
-			//d[i] += d[i-1]
-			d[i] = d[i] + d[i - 1];
-			c[i] /= -b[i];
-			d[i] /= -b[i];
-		}
-
-		// at this point b[i] == -a[i + 1], a[i] == 0,
-		// do row operations to eliminate 'c' coefficients and solve
-		d[n - 1] *= -1.0;
-		for i in (0..n - 1).rev() {
-			d[i] = d[i] - (c[i] * d[i + 1]);
-			d[i] *= -1.0; //d[i] /= b[i]
-		}
-
-		// given the second point in the n'th cubic bezier, the third point is given by 2 * points[n+1] - b[n+1].
-		// to find 'handle1_pos' for the n'th point we need the n-1 cubic bezier
-		new.0.push_end(VectorAnchor::new_with_handles(points[0], None, Some(d[0])));
-		for i in 1..n - 1 {
-			new.0.push_end(VectorAnchor::new_with_handles(points[i], Some(2.0 * points[i] - d[i]), Some(d[i])));
-		}
-		new.0.push_end(VectorAnchor::new_with_handles(points[n - 1], Some(2.0 * points[n - 1] - d[n - 1]), None));
-
-		new
-	}
-
-	/// Move the selected points by the delta vector
-	pub fn move_selected(&mut self, delta: DVec2, absolute_position: DVec2, viewspace: &DAffine2) {
-		self.selected_anchors_any_points_mut()
-			.for_each(|anchor| anchor.move_selected_points(delta, absolute_position, viewspace));
-	}
-
-	/// Delete the selected points from the VectorShape
-	pub fn delete_selected(&mut self) {
-		let mut ids_to_delete: Vec<u64> = vec![];
-		for (id, anchor) in self.anchors_mut().enumerate_mut() {
-			if anchor.is_anchor_selected() {
-				ids_to_delete.push(*id);
-			} else {
-				anchor.delete_selected();
-			}
-		}
-
-		for id in ids_to_delete {
-			self.anchors_mut().remove(id);
-		}
-	}
-
-	// Apply a transformation to all of the VectorShape points
-	pub fn apply_affine(&mut self, affine: DAffine2) {
-		for anchor in self.anchors_mut().iter_mut() {
-			anchor.transform(&affine);
-		}
-	}
-
-	// ** SELECTION OF POINTS **
-
-	/// Select a single point by providing (AnchorId, ControlPointType)
-	pub fn select_point(&mut self, point: (u64, ControlPointType), selected: bool) -> Option<&mut VectorAnchor> {
-		let (anchor_id, point_id) = point;
-		if let Some(anchor) = self.anchors_mut().by_id_mut(anchor_id) {
-			anchor.select_point(point_id as usize, selected);
-			return Some(anchor);
-		}
-		None
-	}
-
-	/// Select points in the VectorShape, given by (AnchorId, ControlPointType)
-	pub fn select_points(&mut self, points: &[(u64, ControlPointType)], selected: bool) {
-		points.iter().for_each(|point| {
-			self.select_point(*point, selected);
-		});
-	}
-
-	/// Select all the anchors in this shape
-	pub fn select_all_anchors(&mut self) {
-		for anchor in self.anchors_mut().iter_mut() {
-			anchor.select_point(ControlPointType::Anchor as usize, true);
-		}
-	}
-
-	/// Select an anchor by index
-	pub fn select_anchor_by_index(&mut self, anchor_index: usize) -> Option<&mut VectorAnchor> {
-		if let Some(anchor) = self.anchors_mut().by_index_mut(anchor_index) {
-			anchor.select_point(ControlPointType::Anchor as usize, true);
-			return Some(anchor);
-		}
-		None
-	}
-
-	/// The last anchor in the shape
-	pub fn select_last_anchor(&mut self) -> Option<&mut VectorAnchor> {
-		if let Some(anchor) = self.anchors_mut().last_mut() {
-			anchor.select_point(ControlPointType::Anchor as usize, true);
-			return Some(anchor);
-		}
-		None
-	}
-
-	/// Clear all the selected anchors, and clear the selected points on the anchors
-	pub fn clear_selected_anchors(&mut self) {
-		for anchor in self.anchors_mut().iter_mut() {
-			anchor.clear_selected_points();
-		}
-	}
-
-	// ** ACCESSING ANCHORS **
-
-	/// Return all the selected anchors, reference
-	pub fn selected_anchors(&self) -> impl Iterator<Item = &VectorAnchor> {
-		self.anchors().iter().filter(|anchor| anchor.is_anchor_selected())
-	}
-
-	/// Return all the selected anchors, mutable
-	pub fn selected_anchors_mut(&mut self) -> impl Iterator<Item = &mut VectorAnchor> {
-		self.anchors_mut().iter_mut().filter(|anchor| anchor.is_anchor_selected())
-	}
-
-	/// Return all the selected anchors that have any children points selected, reference
-	pub fn selected_anchors_any_points(&self) -> impl Iterator<Item = &VectorAnchor> {
-		self.anchors().iter().filter(|anchor| anchor.any_points_selected())
-	}
-
-	/// Return all the selected anchors that have any children points selected, mutable
-	pub fn selected_anchors_any_points_mut(&mut self) -> impl Iterator<Item = &mut VectorAnchor> {
-		self.anchors_mut().iter_mut().filter(|anchor| anchor.any_points_selected())
-	}
-
-	/// An alias for `self.0`
-	pub fn anchors(&self) -> &IdBackedVec<VectorAnchor> {
-		&self.0
-	}
-
-	/// Returns a [VectorControlPoint] from the last [VectorAnchor]
-	pub fn last_point(&self, control_type: ControlPointType) -> Option<&VectorControlPoint> {
-		self.anchors().last().and_then(|anchor| anchor.points[control_type].as_ref())
-	}
-
-	/// Returns a [VectorControlPoint] from the last [VectorAnchor], mutably
-	pub fn last_point_mut(&mut self, control_type: ControlPointType) -> Option<&mut VectorControlPoint> {
-		self.anchors_mut().last_mut().and_then(|anchor| anchor.points[control_type].as_mut())
-	}
-
-	/// Returns a [VectorControlPoint]  from the first [VectorAnchor]
-	pub fn first_point(&self, control_type: ControlPointType) -> Option<&VectorControlPoint> {
-		self.anchors().first().and_then(|anchor| anchor.points[control_type].as_ref())
-	}
-
-	/// Returns a [VectorControlPoint] from the first [VectorAnchor]
-	pub fn first_point_mut(&mut self, control_type: ControlPointType) -> Option<&mut VectorControlPoint> {
-		self.anchors_mut().first_mut().and_then(|anchor| anchor.points[control_type].as_mut())
-	}
-
-	/// Should we close the shape?
-	pub fn should_close_shape(&self) -> bool {
-		if self.last_point(ControlPointType::Anchor).is_none() {
-			return false;
-		}
-
-		self.first_point(ControlPointType::Anchor)
-			.unwrap()
-			.position
-			.distance(self.last_point(ControlPointType::Anchor).unwrap().position)
-			< 0.001 // TODO Replace with constant, a small epsilon
-	}
-
-	/// Close the shape if able
-	pub fn close_shape(&mut self) {
-		if self.should_close_shape() {
-			self.anchors_mut().push_end(VectorAnchor::closed());
-		}
-	}
-
-	/// An alias for `self.0` mutable
-	pub fn anchors_mut(&mut self) -> &mut IdBackedVec<VectorAnchor> {
-		&mut self.0
-	}
-
-	// ** INTERFACE WITH KURBO **
-
-	// TODO Implement our own a local bounding box calculation
-	/// Return the bounding box of the shape
-	pub fn bounding_box(&self) -> Rect {
-		<&Self as Into<BezPath>>::into(self).bounding_box()
-	}
-
-	/// Use kurbo to convert this shape into an SVG path
-	pub fn to_svg(&mut self) -> String {
-		fn write_positions(result: &mut String, values: [Option<DVec2>; 3]) {
-			use std::fmt::Write;
-			let count = values.into_iter().flatten().count();
-			for (index, pos) in values.into_iter().flatten().enumerate() {
-				write!(result, "{},{}", pos.x, pos.y).unwrap();
-				if index != count - 1 {
-					result.push(' ');
-				}
-			}
-		}
-
-		let mut result = String::new();
-		// The out position from the previous VectorAnchor
-		let mut last_out_handle = None;
-		// The values from the last moveto (for closing the path)
-		let (mut first_in_handle, mut first_in_anchor) = (None, None);
-		// Should the next element be a moveto?
-		let mut start_new_contour = true;
-		for vector_anchor in self.anchors().iter() {
-			let in_handle = vector_anchor.points[ControlPointType::InHandle].as_ref().map(|anchor| anchor.position);
-			let anchor = vector_anchor.points[ControlPointType::Anchor].as_ref().map(|anchor| anchor.position);
-			let out_handle = vector_anchor.points[ControlPointType::OutHandle].as_ref().map(|anchor| anchor.position);
-
-			let command = match (last_out_handle.is_some(), in_handle.is_some(), anchor.is_some()) {
-				(_, _, true) if start_new_contour => 'M',
-				(true, false, true) | (false, true, true) => 'Q',
-				(true, true, true) => 'C',
-				(false, false, true) => 'L',
-				(_, false, false) => 'Z',
-				_ => panic!("Invalid shape {:#?}", self),
-			};
-
-			// Complete the last curve
-			if command == 'Z' {
-				if last_out_handle.is_some() && first_in_handle.is_some() {
-					result.push('C');
-					write_positions(&mut result, [last_out_handle, first_in_handle, first_in_anchor]);
-				} else if last_out_handle.is_some() || first_in_handle.is_some() {
-					result.push('Q');
-					write_positions(&mut result, [last_out_handle, first_in_handle, first_in_anchor]);
-				} else {
-					result.push('Z');
-				}
-			} else if command == 'M' {
-				// Update the last moveto position
-				(first_in_handle, first_in_anchor) = (in_handle, anchor);
-				result.push(command);
-				write_positions(&mut result, [None, None, anchor]);
-			} else {
-				result.push(command);
-				write_positions(&mut result, [last_out_handle, in_handle, anchor]);
-			}
-			start_new_contour = command == 'Z';
-			last_out_handle = out_handle;
-		}
-		result
-	}
-}
-
-// ** CONVERSIONS **
-
-/// Convert a mutable layer into a mutable VectorShape
-impl<'a> TryFrom<&'a mut Layer> for &'a mut VectorShape {
-	type Error = &'static str;
-	fn try_from(layer: &'a mut Layer) -> Result<&'a mut VectorShape, Self::Error> {
-		match &mut layer.data {
-			LayerDataType::Shape(layer) => Ok(&mut layer.shape),
-			// TODO Resolve converting text into a VectorShape at the layer level
-			// LayerDataType::Text(text) => Some(VectorShape::new(path_to_shape.to_vec(), viewport_transform, true)),
-			_ => Err("Did not find any shape data in the layer"),
-		}
-	}
-}
-
-/// Convert a reference to a layer into a reference of a VectorShape
-impl<'a> TryFrom<&'a Layer> for &'a VectorShape {
-	type Error = &'static str;
-	fn try_from(layer: &'a Layer) -> Result<&'a VectorShape, Self::Error> {
-		match &layer.data {
-			LayerDataType::Shape(layer) => Ok(&layer.shape),
-			// TODO Resolve converting text into a VectorShape at the layer level
-			// LayerDataType::Text(text) => Some(VectorShape::new(path_to_shape.to_vec(), viewport_transform, true)),
-			_ => Err("Did not find any shape data in the layer"),
-		}
-	}
-}
-
-/// Create a BezPath from a VectorShape
-impl From<&VectorShape> for BezPath {
-	fn from(vector_shape: &VectorShape) -> Self {
-		// Take anchors and create path elements: line, quad or curve, or a close indicator
-		let anchors_to_path_el = |first: &VectorAnchor, second: &VectorAnchor| -> (PathEl, bool) {
-			match [
-				&first.points[ControlPointType::OutHandle],
-				&second.points[ControlPointType::InHandle],
-				&second.points[ControlPointType::Anchor],
-			] {
-				[None, None, Some(anchor)] => (PathEl::LineTo(point_to_kurbo(anchor)), false),
-				[None, Some(in_handle), Some(anchor)] => (PathEl::QuadTo(point_to_kurbo(in_handle), point_to_kurbo(anchor)), false),
-				[Some(out_handle), None, Some(anchor)] => (PathEl::QuadTo(point_to_kurbo(out_handle), point_to_kurbo(anchor)), false),
-				[Some(out_handle), Some(in_handle), Some(anchor)] => (PathEl::CurveTo(point_to_kurbo(out_handle), point_to_kurbo(in_handle), point_to_kurbo(anchor)), false),
-				[Some(out_handle), None, None] => {
-					if let Some(first_anchor) = vector_shape.anchors().first() {
-						(
-							if let Some(in_handle) = &first_anchor.points[ControlPointType::InHandle] {
-								PathEl::CurveTo(
-									point_to_kurbo(out_handle),
-									point_to_kurbo(in_handle),
-									point_to_kurbo(first_anchor.points[ControlPointType::Anchor].as_ref().unwrap()),
-								)
-							} else {
-								PathEl::QuadTo(point_to_kurbo(out_handle), point_to_kurbo(first_anchor.points[ControlPointType::Anchor].as_ref().unwrap()))
-							},
-							true,
-						)
-					} else {
-						(PathEl::ClosePath, true)
-					}
-				}
-				[None, None, None] => (PathEl::ClosePath, true),
-				_ => panic!("Invalid path element {:#?}", vector_shape),
-			}
-		};
-
-		if vector_shape.anchors().is_empty() {
-			return BezPath::new();
-		}
-
-		let mut bez_path = vec![];
-		let mut start_new_shape = true;
-
-		for elements in vector_shape.anchors().windows(2) {
-			let first = &elements[0];
-			let second = &elements[1];
-
-			// Tell kurbo cursor to move to the first anchor
-			if start_new_shape {
-				if let Some(anchor) = &first.points[ControlPointType::Anchor] {
-					bez_path.push(PathEl::MoveTo(point_to_kurbo(anchor)));
-				}
-			}
-
-			// Create a path element from our first, second anchors in the window
-			let (path_el, should_start_new_shape) = anchors_to_path_el(first, second);
-			start_new_shape = should_start_new_shape;
-			bez_path.push(path_el);
-			if should_start_new_shape && bez_path.last().filter(|&&el| el == PathEl::ClosePath).is_none() {
-				bez_path.push(PathEl::ClosePath)
-			}
-		}
-
-		BezPath::from_vec(bez_path)
-	}
-}
-
-/// Create a VectorShape from a BezPath
-impl<T: Iterator<Item = PathEl>> From<T> for VectorShape {
-	fn from(path: T) -> Self {
-		let mut vector_shape = VectorShape::new();
-		for path_el in path {
-			match path_el {
-				PathEl::MoveTo(p) => {
-					vector_shape.anchors_mut().push_end(VectorAnchor::new(kurbo_point_to_dvec2(p)));
-				}
-				PathEl::LineTo(p) => {
-					vector_shape.anchors_mut().push_end(VectorAnchor::new(kurbo_point_to_dvec2(p)));
-				}
-				PathEl::QuadTo(p0, p1) => {
-					vector_shape.anchors_mut().push_end(VectorAnchor::new(kurbo_point_to_dvec2(p1)));
-					vector_shape.anchors_mut().last_mut().unwrap().points[ControlPointType::InHandle] = Some(VectorControlPoint::new(kurbo_point_to_dvec2(p0), ControlPointType::InHandle));
-				}
-				PathEl::CurveTo(p0, p1, p2) => {
-					vector_shape.anchors_mut().last_mut().unwrap().points[ControlPointType::OutHandle] = Some(VectorControlPoint::new(kurbo_point_to_dvec2(p0), ControlPointType::OutHandle));
-					vector_shape.anchors_mut().push_end(VectorAnchor::new(kurbo_point_to_dvec2(p2)));
-					vector_shape.anchors_mut().last_mut().unwrap().points[ControlPointType::InHandle] = Some(VectorControlPoint::new(kurbo_point_to_dvec2(p1), ControlPointType::InHandle));
-				}
-				PathEl::ClosePath => {
-					vector_shape.anchors_mut().push_end(VectorAnchor::closed());
-				}
-			}
-		}
-
-		vector_shape
-	}
-}
-
-#[inline]
-fn point_to_kurbo(point: &VectorControlPoint) -> kurbo::Point {
-	kurbo::Point::new(point.position.x, point.position.y)
-}
-
-#[inline]
-fn kurbo_point_to_dvec2(point: kurbo::Point) -> DVec2 {
-	DVec2::new(point.x, point.y)
-}
diff --git a/graphene/src/operation.rs b/graphene/src/operation.rs
index 8f9bc14a..e29deefb 100644
--- a/graphene/src/operation.rs
+++ b/graphene/src/operation.rs
@@ -2,9 +2,9 @@ use crate::boolean_ops::BooleanOperation as BooleanOperationType;
 use crate::layers::blend_mode::BlendMode;
 use crate::layers::layer_info::Layer;
 use crate::layers::style::{self, Stroke};
-use crate::layers::vector::constants::ControlPointType;
-use crate::layers::vector::vector_anchor::VectorAnchor;
-use crate::layers::vector::vector_shape::VectorShape;
+use crate::layers::vector::constants::ManipulatorType;
+use crate::layers::vector::manipulator_group::ManipulatorGroup;
+use crate::layers::vector::subpath::Subpath;
 use crate::LayerId;
 
 use serde::{Deserialize, Serialize};
@@ -89,7 +89,8 @@ pub enum Operation {
 		path: Vec<LayerId>,
 		transform: [f64; 6],
 		insert_index: isize,
-		vector_path: VectorShape,
+		// TODO This will become a compound path once we support them.
+		subpath: Subpath,
 		style: style::PathStyle,
 	},
 	BooleanOperation {
@@ -99,14 +100,14 @@ pub enum Operation {
 	DeleteLayer {
 		path: Vec<LayerId>,
 	},
-	DeleteSelectedVectorPoints {
+	DeleteSelectedManipulatorPoints {
 		layer_paths: Vec<Vec<LayerId>>,
 	},
-	DeselectVectorPoints {
+	DeselectManipulatorPoints {
 		layer_path: Vec<LayerId>,
-		point_ids: Vec<(u64, ControlPointType)>,
+		point_ids: Vec<(u64, ManipulatorType)>,
 	},
-	DeselectAllVectorPoints {
+	DeselectAllManipulatorPoints {
 		layer_path: Vec<LayerId>,
 	},
 	DuplicateLayer {
@@ -118,11 +119,17 @@ pub enum Operation {
 		font_style: String,
 		size: f64,
 	},
-	MoveSelectedVectorPoints {
+	MoveSelectedManipulatorPoints {
 		layer_path: Vec<LayerId>,
 		delta: (f64, f64),
 		absolute_position: (f64, f64),
 	},
+	MoveManipulatorPoint {
+		layer_path: Vec<LayerId>,
+		id: u64,
+		manipulator_type: ManipulatorType,
+		position: (f64, f64),
+	},
 	RenameLayer {
 		layer_path: Vec<LayerId>,
 		new_name: String,
@@ -147,38 +154,32 @@ pub enum Operation {
 		path: Vec<LayerId>,
 		transform: [f64; 6],
 	},
-	SelectVectorPoints {
+	SelectManipulatorPoints {
 		layer_path: Vec<LayerId>,
-		point_ids: Vec<(u64, ControlPointType)>,
+		point_ids: Vec<(u64, ManipulatorType)>,
 		add: bool,
 	},
 	SetShapePath {
 		path: Vec<LayerId>,
-		vector_path: VectorShape,
+		subpath: Subpath,
 	},
-	InsertVectorAnchor {
+	InsertManipulatorGroup {
 		layer_path: Vec<LayerId>,
-		anchor: VectorAnchor,
+		manipulator_group: ManipulatorGroup,
 		after_id: u64,
 	},
-	PushVectorAnchor {
+	PushManipulatorGroup {
 		layer_path: Vec<LayerId>,
-		anchor: VectorAnchor,
+		manipulator_group: ManipulatorGroup,
 	},
-	RemoveVectorAnchor {
+	RemoveManipulatorGroup {
 		layer_path: Vec<LayerId>,
 		id: u64,
 	},
-	MoveVectorPoint {
+	RemoveManipulatorPoint {
 		layer_path: Vec<LayerId>,
 		id: u64,
-		control_type: ControlPointType,
-		position: (f64, f64),
-	},
-	RemoveVectorPoint {
-		layer_path: Vec<LayerId>,
-		id: u64,
-		control_type: ControlPointType,
+		manipulator_type: ManipulatorType,
 	},
 	TransformLayerInScope {
 		path: Vec<LayerId>,
diff --git a/proc-macros/src/helper_structs.rs b/proc-macros/src/helper_structs.rs
index ecec648c..3900ff4f 100644
--- a/proc-macros/src/helper_structs.rs
+++ b/proc-macros/src/helper_structs.rs
@@ -138,8 +138,8 @@ pub struct SimpleCommaDelimeted<T>(pub Vec<T>);
 
 impl<T: Parse> Parse for SimpleCommaDelimeted<T> {
 	fn parse(input: ParseStream) -> syn::Result<Self> {
-		let punct = Punctuated::<T, Token![,]>::parse_terminated(input)?;
-		Ok(Self(punct.into_iter().collect()))
+		let punctuated = Punctuated::<T, Token![,]>::parse_terminated(input)?;
+		Ok(Self(punctuated.into_iter().collect()))
 	}
 }
 
diff --git a/proc-macros/src/helpers.rs b/proc-macros/src/helpers.rs
index 4461e4b4..486c6ff7 100644
--- a/proc-macros/src/helpers.rs
+++ b/proc-macros/src/helpers.rs
@@ -24,7 +24,7 @@ pub fn call_site_ident<S: AsRef<str>>(s: S) -> Ident {
 	Ident::new(s.as_ref(), Span::call_site())
 }
 
-/// Creates the path `left::right` from the idents `left` and `right`
+/// Creates the path `left::right` from the identifiers `left` and `right`
 pub fn two_segment_path(left_ident: Ident, right_ident: Ident) -> Path {
 	let mut segments: Punctuated<PathSegment, Token![::]> = Punctuated::new();
 	segments.push(PathSegment {
diff --git a/proc-macros/src/lib.rs b/proc-macros/src/lib.rs
index e09f6542..d71a37e6 100644
--- a/proc-macros/src/lib.rs
+++ b/proc-macros/src/lib.rs
@@ -187,7 +187,7 @@ pub fn derive_message(input_item: TokenStream) -> TokenStream {
 	TokenStream::from(derive_as_message_impl(input_item.into()).unwrap_or_else(|err| err.to_compile_error()))
 }
 
-/// This macro is basically an abbreviation for the usual [`ToDiscriminant`], [`TransitiveChild`] and [`AsMessage`] invocations
+/// This macro is basically an abbreviation for the usual [ToDiscriminant], [TransitiveChild] and [AsMessage] invocations.
 ///
 /// This macro is enum-only.
 ///
diff --git a/website/config.toml b/website/config.toml
index 94ce807a..8e0af29a 100644
--- a/website/config.toml
+++ b/website/config.toml
@@ -8,7 +8,7 @@ feed_filename = "rss.xml"
 
 [markdown]
 # Whether to do syntax highlighting
-# Theme can be customised by setting the `highlight_theme` variable to a theme supported by Zola
+# Theme can be customized by setting the `highlight_theme` variable to a theme supported by Zola
 highlight_code = true
 highlight_theme = "css"