diff --git a/Cargo.lock b/Cargo.lock
index f6211650f901..c063508b4723 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4510,6 +4510,7 @@ dependencies = [
  "macaw",
  "re_build_tools",
  "re_types_builder",
+ "similar-asserts",
  "xshell",
 ]
 
diff --git a/crates/re_types/Cargo.toml b/crates/re_types/Cargo.toml
index 4da294c84c50..d596ff1b9347 100644
--- a/crates/re_types/Cargo.toml
+++ b/crates/re_types/Cargo.toml
@@ -49,6 +49,7 @@ macaw = { workspace = true, optional = true }
 # External
 glam.workspace = true
 itertools.workspace = true
+similar-asserts = "1.4.2"
 
 
 [build-dependencies]
diff --git a/crates/re_types/definitions/rerun/components/draw_order.fbs b/crates/re_types/definitions/rerun/components/draw_order.fbs
index 819fb82f26e6..5286937a80bf 100644
--- a/crates/re_types/definitions/rerun/components/draw_order.fbs
+++ b/crates/re_types/definitions/rerun/components/draw_order.fbs
@@ -20,7 +20,7 @@ struct DrawOrder (
   "attr.arrow.transparent",
   "attr.python.aliases": "float",
   "attr.python.array_aliases": "npt.NDArray[np.float32]",
-  "attr.rust.derive": "Debug, Clone, Copy, PartialEq, PartialOrd",
+  "attr.rust.derive": "Debug, Clone, Copy",
   "attr.rust.repr": "transparent",
   "attr.rust.tuple_struct",
   order: 100
diff --git a/crates/re_types/src/components/class_id_ext.rs b/crates/re_types/src/components/class_id_ext.rs
new file mode 100644
index 000000000000..60da05d4a0e1
--- /dev/null
+++ b/crates/re_types/src/components/class_id_ext.rs
@@ -0,0 +1,7 @@
+use super::ClassId;
+
+impl From<u16> for ClassId {
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
+}
diff --git a/crates/re_types/src/components/color_ext.rs b/crates/re_types/src/components/color_ext.rs
new file mode 100644
index 000000000000..ea0703868e7e
--- /dev/null
+++ b/crates/re_types/src/components/color_ext.rs
@@ -0,0 +1,50 @@
+use super::Color;
+
+impl Color {
+    #[inline]
+    pub fn from_rgb(r: u8, g: u8, b: u8) -> Self {
+        Self::from([r, g, b, 255])
+    }
+
+    #[inline]
+    pub fn from_unmultiplied_rgba(r: u8, g: u8, b: u8, a: u8) -> Self {
+        Self::from([r, g, b, a])
+    }
+
+    #[inline]
+    pub fn to_array(&self) -> [u8; 4] {
+        [
+            (self.0 >> 24) as u8,
+            (self.0 >> 16) as u8,
+            (self.0 >> 8) as u8,
+            self.0 as u8,
+        ]
+    }
+}
+
+impl From<u32> for Color {
+    #[inline]
+    fn from(c: u32) -> Self {
+        Self(c)
+    }
+}
+
+impl From<[u8; 4]> for Color {
+    #[inline]
+    fn from(bytes: [u8; 4]) -> Self {
+        Self(
+            (bytes[0] as u32) << 24
+                | (bytes[1] as u32) << 16
+                | (bytes[2] as u32) << 8
+                | (bytes[3] as u32),
+        )
+    }
+}
+
+#[cfg(feature = "ecolor")]
+impl From<Color> for ecolor::Color32 {
+    fn from(color: Color) -> Self {
+        let [r, g, b, a] = color.to_array();
+        Self::from_rgba_premultiplied(r, g, b, a)
+    }
+}
diff --git a/crates/re_types/src/components/draw_order.rs b/crates/re_types/src/components/draw_order.rs
index 3ccf929240b7..16cb87bce10d 100644
--- a/crates/re_types/src/components/draw_order.rs
+++ b/crates/re_types/src/components/draw_order.rs
@@ -7,7 +7,7 @@
 /// Within an entity draw order is governed by the order of the components.
 ///
 /// Draw order for entities with the same draw order is generally undefined.
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, Copy)]
 #[repr(transparent)]
 pub struct DrawOrder(pub f32);
 
diff --git a/crates/re_types/src/components/draw_order_ext.rs b/crates/re_types/src/components/draw_order_ext.rs
new file mode 100644
index 000000000000..f99f10213c56
--- /dev/null
+++ b/crates/re_types/src/components/draw_order_ext.rs
@@ -0,0 +1,60 @@
+use super::DrawOrder;
+
+// TODO(cmc): come up with some DSL in our flatbuffers definitions so that we can declare these
+// constants directly in there.
+impl DrawOrder {
+    /// Draw order used for images if no draw order was specified.
+    pub const DEFAULT_IMAGE: DrawOrder = DrawOrder(-10.0);
+
+    /// Draw order used for 2D boxes if no draw order was specified.
+    pub const DEFAULT_BOX2D: DrawOrder = DrawOrder(10.0);
+
+    /// Draw order used for 2D lines if no draw order was specified.
+    pub const DEFAULT_LINES2D: DrawOrder = DrawOrder(20.0);
+
+    /// Draw order used for 2D points if no draw order was specified.
+    pub const DEFAULT_POINTS2D: DrawOrder = DrawOrder(30.0);
+}
+
+impl std::cmp::PartialEq for DrawOrder {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.0.is_nan() && other.0.is_nan() || self.0 == other.0
+    }
+}
+
+impl std::cmp::Eq for DrawOrder {}
+
+impl std::cmp::PartialOrd for DrawOrder {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        if other == self {
+            Some(std::cmp::Ordering::Equal)
+        } else if other.0.is_nan() || self.0 < other.0 {
+            Some(std::cmp::Ordering::Less)
+        } else {
+            Some(std::cmp::Ordering::Greater)
+        }
+    }
+}
+
+impl std::cmp::Ord for DrawOrder {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.partial_cmp(other).unwrap()
+    }
+}
+
+impl From<f32> for DrawOrder {
+    #[inline]
+    fn from(value: f32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<DrawOrder> for f32 {
+    #[inline]
+    fn from(value: DrawOrder) -> Self {
+        value.0
+    }
+}
diff --git a/crates/re_types/src/components/instance_key_ext.rs b/crates/re_types/src/components/instance_key_ext.rs
new file mode 100644
index 000000000000..c7a40974ebec
--- /dev/null
+++ b/crates/re_types/src/components/instance_key_ext.rs
@@ -0,0 +1,22 @@
+use super::InstanceKey;
+
+// TODO(cmc): come up with some DSL in our flatbuffers definitions so that we can declare these
+// constants directly in there.
+impl InstanceKey {
+    /// Draw order used for images if no draw order was specified.
+    pub const SPLAT: Self = Self(u64::MAX);
+}
+
+impl From<u64> for InstanceKey {
+    #[inline]
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<InstanceKey> for u64 {
+    #[inline]
+    fn from(value: InstanceKey) -> Self {
+        value.0
+    }
+}
diff --git a/crates/re_types/src/components/keypoint_id_ext.rs b/crates/re_types/src/components/keypoint_id_ext.rs
new file mode 100644
index 000000000000..e7293dcdaf72
--- /dev/null
+++ b/crates/re_types/src/components/keypoint_id_ext.rs
@@ -0,0 +1,7 @@
+use super::KeypointId;
+
+impl From<u16> for KeypointId {
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
+}
diff --git a/crates/re_types/src/components/label_ext.rs b/crates/re_types/src/components/label_ext.rs
new file mode 100644
index 000000000000..679284f2b05d
--- /dev/null
+++ b/crates/re_types/src/components/label_ext.rs
@@ -0,0 +1,51 @@
+use super::Label;
+
+impl Label {
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
+impl From<String> for Label {
+    #[inline]
+    fn from(value: String) -> Self {
+        Self(value)
+    }
+}
+
+impl From<&str> for Label {
+    #[inline]
+    fn from(value: &str) -> Self {
+        Self(value.to_owned())
+    }
+}
+
+impl From<Label> for String {
+    #[inline]
+    fn from(value: Label) -> Self {
+        value.0
+    }
+}
+
+impl AsRef<str> for Label {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl std::borrow::Borrow<str> for Label {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl std::ops::Deref for Label {
+    type Target = str;
+    #[inline]
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
diff --git a/crates/re_types/src/components/mod.rs b/crates/re_types/src/components/mod.rs
index 8fe7f6428266..2a14150d0dcb 100644
--- a/crates/re_types/src/components/mod.rs
+++ b/crates/re_types/src/components/mod.rs
@@ -1,13 +1,21 @@
 // NOTE: This file was autogenerated by re_types_builder; DO NOT EDIT.
 
 mod class_id;
+mod class_id_ext;
 mod color;
+mod color_ext;
 mod draw_order;
+mod draw_order_ext;
 mod instance_key;
+mod instance_key_ext;
 mod keypoint_id;
+mod keypoint_id_ext;
 mod label;
+mod label_ext;
 mod point2d;
+mod point2d_ext;
 mod radius;
+mod radius_ext;
 
 pub use self::class_id::ClassId;
 pub use self::color::Color;
diff --git a/crates/re_types/src/components/point2d_ext.rs b/crates/re_types/src/components/point2d_ext.rs
new file mode 100644
index 000000000000..fabb51b3a0fa
--- /dev/null
+++ b/crates/re_types/src/components/point2d_ext.rs
@@ -0,0 +1,57 @@
+use super::Point2D;
+
+impl Point2D {
+    pub const ZERO: Self = Self::new(0.0, 0.0);
+    pub const ONE: Self = Self::new(1.0, 1.0);
+
+    #[inline]
+    pub const fn new(x: f32, y: f32) -> Self {
+        Self(crate::datatypes::Vec2D::new(x, y))
+    }
+}
+
+impl std::ops::Deref for Point2D {
+    type Target = crate::datatypes::Vec2D;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<(f32, f32)> for Point2D {
+    #[inline]
+    fn from(xy: (f32, f32)) -> Self {
+        Self(xy.into())
+    }
+}
+
+impl From<[f32; 2]> for Point2D {
+    #[inline]
+    fn from(p: [f32; 2]) -> Self {
+        Self(p.into())
+    }
+}
+
+#[cfg(feature = "glam")]
+impl From<glam::Vec2> for Point2D {
+    #[inline]
+    fn from(pt: glam::Vec2) -> Self {
+        Self::new(pt.x, pt.y)
+    }
+}
+
+#[cfg(feature = "glam")]
+impl From<Point2D> for glam::Vec2 {
+    #[inline]
+    fn from(pt: Point2D) -> Self {
+        Self::new(pt.x(), pt.y())
+    }
+}
+
+#[cfg(feature = "glam")]
+impl From<Point2D> for glam::Vec3 {
+    #[inline]
+    fn from(pt: Point2D) -> Self {
+        Self::new(pt.x(), pt.y(), 0.0)
+    }
+}
diff --git a/crates/re_types/src/components/radius_ext.rs b/crates/re_types/src/components/radius_ext.rs
new file mode 100644
index 000000000000..baccbe5c2c97
--- /dev/null
+++ b/crates/re_types/src/components/radius_ext.rs
@@ -0,0 +1,24 @@
+use super::Radius;
+
+impl Radius {
+    pub const ZERO: Self = Self::new(0.0);
+    pub const ONE: Self = Self::new(1.0);
+
+    #[inline]
+    pub const fn new(r: f32) -> Self {
+        Self(r)
+    }
+}
+
+impl From<f32> for Radius {
+    #[inline]
+    fn from(r: f32) -> Self {
+        Self::new(r)
+    }
+}
+
+impl std::fmt::Display for Radius {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:.prec$}", self.0, prec = crate::DISPLAY_PRECISION,)
+    }
+}
diff --git a/crates/re_types/src/datatypes/mod.rs b/crates/re_types/src/datatypes/mod.rs
index 894c386d7e99..b0247e086e63 100644
--- a/crates/re_types/src/datatypes/mod.rs
+++ b/crates/re_types/src/datatypes/mod.rs
@@ -1,5 +1,6 @@
 // NOTE: This file was autogenerated by re_types_builder; DO NOT EDIT.
 
 mod vec2d;
+mod vec2d_ext;
 
 pub use self::vec2d::Vec2D;
diff --git a/crates/re_types/src/datatypes/vec2d_ext.rs b/crates/re_types/src/datatypes/vec2d_ext.rs
new file mode 100644
index 000000000000..f9062b5b14c1
--- /dev/null
+++ b/crates/re_types/src/datatypes/vec2d_ext.rs
@@ -0,0 +1,73 @@
+use super::Vec2D;
+
+impl Vec2D {
+    pub const ZERO: Self = Self::new(0.0, 0.0);
+    pub const ONE: Self = Self::new(1.0, 1.0);
+
+    #[inline]
+    pub const fn new(x: f32, y: f32) -> Self {
+        Self([x, y])
+    }
+
+    #[inline]
+    pub fn x(&self) -> f32 {
+        self.0[0]
+    }
+
+    #[inline]
+    pub fn y(&self) -> f32 {
+        self.0[1]
+    }
+}
+
+impl From<(f32, f32)> for Vec2D {
+    #[inline]
+    fn from((x, y): (f32, f32)) -> Self {
+        Self::new(x, y)
+    }
+}
+
+impl From<[f32; 2]> for Vec2D {
+    #[inline]
+    fn from(v: [f32; 2]) -> Self {
+        Self(v)
+    }
+}
+
+impl<Idx> std::ops::Index<Idx> for Vec2D
+where
+    Idx: std::slice::SliceIndex<[f32]>,
+{
+    type Output = Idx::Output;
+
+    #[inline]
+    fn index(&self, index: Idx) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
+#[cfg(feature = "glam")]
+impl From<Vec2D> for glam::Vec2 {
+    fn from(v: Vec2D) -> Self {
+        Self::from_slice(&v.0)
+    }
+}
+
+#[cfg(feature = "glam")]
+impl From<glam::Vec2> for Vec2D {
+    fn from(v: glam::Vec2) -> Self {
+        Self(v.to_array())
+    }
+}
+
+impl std::fmt::Display for Vec2D {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "[{:.prec$}, {:.prec$}]",
+            self.x(),
+            self.y(),
+            prec = crate::DISPLAY_PRECISION,
+        )
+    }
+}
diff --git a/crates/re_types/tests/points2d.rs b/crates/re_types/tests/points2d.rs
new file mode 100644
index 000000000000..85b79182b0e5
--- /dev/null
+++ b/crates/re_types/tests/points2d.rs
@@ -0,0 +1,49 @@
+use re_types::{archetypes::Points2D, components};
+
+#[test]
+fn roundtrip() {
+    // TODO(cmc): (de)serialization roundtrips
+
+    let arch = Points2D::new([(1.0, 2.0), (3.0, 4.0)])
+        .with_radii([42.0, 43.0])
+        .with_colors([0xAA0000CC, 0x00BB00DD])
+        .with_labels(["hello", "friend"])
+        .with_draw_order(300.0)
+        .with_class_ids([126, 127])
+        .with_keypoint_ids([2, 3])
+        .with_instance_keys([u64::MAX - 1, u64::MAX]);
+
+    let expected = Points2D {
+        points: vec![
+            components::Point2D::new(1.0, 2.0), //
+            components::Point2D::new(3.0, 4.0),
+        ],
+        radii: Some(vec![
+            components::Radius(42.0), //
+            components::Radius(43.0),
+        ]),
+        colors: Some(vec![
+            components::Color::from_unmultiplied_rgba(0xAA, 0x00, 0x00, 0xCC), //
+            components::Color::from_unmultiplied_rgba(0x00, 0xBB, 0x00, 0xDD),
+        ]),
+        labels: Some(vec![
+            components::Label("hello".to_owned()),  //
+            components::Label("friend".to_owned()), //
+        ]),
+        draw_order: Some(components::DrawOrder(300.0)),
+        class_ids: Some(vec![
+            components::ClassId(126), //
+            components::ClassId(127), //
+        ]),
+        keypoint_ids: Some(vec![
+            components::KeypointId(2), //
+            components::KeypointId(3), //
+        ]),
+        instance_keys: Some(vec![
+            components::InstanceKey(u64::MAX - 1), //
+            components::InstanceKey(u64::MAX),
+        ]),
+    };
+
+    similar_asserts::assert_eq!(expected, arch);
+}