diff --git a/Cargo.lock b/Cargo.lock
index b249a7befbd4..d0ee46a24908 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1220,6 +1220,7 @@ name = "custom_space_view"
 version = "0.9.0-alpha.0"
 dependencies = [
  "mimalloc",
+ "once_cell",
  "re_crash_handler",
  "re_sdk_comms",
  "re_viewer",
@@ -3253,9 +3254,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.17.1"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
 
 [[package]]
 name = "oorandom"
@@ -4556,6 +4557,7 @@ version = "0.9.0-alpha.0"
 dependencies = [
  "anyhow",
  "arrow2",
+ "arrow2_convert",
  "backtrace",
  "bytemuck",
  "document-features",
diff --git a/crates/re_arrow_store/benches/arrow2.rs b/crates/re_arrow_store/benches/arrow2.rs
index 578591987101..3c5c6ca624df 100644
--- a/crates/re_arrow_store/benches/arrow2.rs
+++ b/crates/re_arrow_store/benches/arrow2.rs
@@ -10,10 +10,13 @@ use criterion::{criterion_group, Criterion};
 use itertools::Itertools;
 use re_components::{
     datagen::{build_some_instances, build_some_point2d, build_some_rects},
-    Point2D, Rect2D,
+    Rect2D,
 };
 use re_log_types::{DataCell, SizeBytes as _};
-use re_types::{components::InstanceKey, Component};
+use re_types::{
+    components::{InstanceKey, Point2D},
+    Component,
+};
 
 // ---
 
diff --git a/crates/re_arrow_store/examples/latest_component.rs b/crates/re_arrow_store/examples/latest_component.rs
index 4c859e4966c4..d026983b5511 100644
--- a/crates/re_arrow_store/examples/latest_component.rs
+++ b/crates/re_arrow_store/examples/latest_component.rs
@@ -8,10 +8,13 @@ use re_arrow_store::polars_util::latest_component;
 use re_arrow_store::{test_row, DataStore, LatestAtQuery, TimeType, Timeline};
 use re_components::{
     datagen::{build_frame_nr, build_some_point2d, build_some_rects},
-    Point2D, Rect2D,
+    Rect2D,
 };
 use re_log_types::EntityPath;
-use re_types::{components::InstanceKey, Loggable};
+use re_types::{
+    components::{InstanceKey, Point2D},
+    Loggable,
+};
 
 fn main() {
     let mut store = DataStore::new(InstanceKey::name(), Default::default());
diff --git a/crates/re_arrow_store/examples/latest_components.rs b/crates/re_arrow_store/examples/latest_components.rs
index b1023d548816..3fab9591d716 100644
--- a/crates/re_arrow_store/examples/latest_components.rs
+++ b/crates/re_arrow_store/examples/latest_components.rs
@@ -10,10 +10,13 @@ use re_arrow_store::polars_util::latest_components;
 use re_arrow_store::{test_row, DataStore, LatestAtQuery, TimeType, Timeline};
 use re_components::{
     datagen::{build_frame_nr, build_some_point2d, build_some_rects},
-    Point2D, Rect2D,
+    Rect2D,
 };
 use re_log_types::EntityPath;
-use re_types::{components::InstanceKey, Loggable};
+use re_types::{
+    components::{InstanceKey, Point2D},
+    Loggable,
+};
 
 fn main() {
     let mut store = DataStore::new(InstanceKey::name(), Default::default());
diff --git a/crates/re_arrow_store/examples/range_components.rs b/crates/re_arrow_store/examples/range_components.rs
index 14e71b0398cc..ac0bb2532822 100644
--- a/crates/re_arrow_store/examples/range_components.rs
+++ b/crates/re_arrow_store/examples/range_components.rs
@@ -8,10 +8,13 @@ use polars_core::prelude::JoinType;
 use re_arrow_store::{polars_util, test_row, DataStore, RangeQuery, TimeRange};
 use re_components::{
     datagen::{build_frame_nr, build_some_point2d, build_some_rects},
-    Point2D, Rect2D,
+    Rect2D,
 };
 use re_log_types::{EntityPath, TimeType, Timeline};
-use re_types::{components::InstanceKey, Loggable};
+use re_types::{
+    components::{InstanceKey, Point2D},
+    Loggable as _,
+};
 
 fn main() {
     let mut store = DataStore::new(InstanceKey::name(), Default::default());
diff --git a/crates/re_arrow_store/src/store_write.rs b/crates/re_arrow_store/src/store_write.rs
index 526c16eb715c..ef988dc65a74 100644
--- a/crates/re_arrow_store/src/store_write.rs
+++ b/crates/re_arrow_store/src/store_write.rs
@@ -85,11 +85,15 @@ impl DataStore {
                 use std::collections::hash_map::Entry;
                 match self.type_registry.entry(cell.component_name()) {
                     Entry::Occupied(entry) => {
-                        if entry.get() != cell.datatype() {
+                        // NOTE: Don't care about extensions until the migration is over (arrow2-convert
+                        // issues).
+                        let expected = entry.get().to_logical_type().clone();
+                        let got = cell.datatype().to_logical_type().clone();
+                        if expected != got {
                             return Err(WriteError::TypeCheck {
                                 component: cell.component_name(),
-                                expected: entry.get().clone(),
-                                got: cell.datatype().clone(),
+                                expected,
+                                got,
                             });
                         }
                     }
diff --git a/crates/re_arrow_store/tests/correctness.rs b/crates/re_arrow_store/tests/correctness.rs
index 7357bbead031..05c41f8f1a51 100644
--- a/crates/re_arrow_store/tests/correctness.rs
+++ b/crates/re_arrow_store/tests/correctness.rs
@@ -217,7 +217,7 @@ fn range_join_across_single_row_impl(store: &mut DataStore) {
         prelude::{DataFrame, JoinType},
         series::Series,
     };
-    use re_components::{ColorRGBA, Point2D};
+    use re_types::components::{Color, Point2D};
 
     let ent_path = EntityPath::from("this/that");
 
@@ -232,7 +232,7 @@ fn range_join_across_single_row_impl(store: &mut DataStore) {
         timeline_frame_nr,
         re_arrow_store::TimeRange::new(i64::MIN.into(), i64::MAX.into()),
     );
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let dfs = re_arrow_store::polars_util::range_components(
         store,
         &query,
@@ -247,12 +247,12 @@ fn range_join_across_single_row_impl(store: &mut DataStore) {
         let instances =
             InstanceKey::to_arrow(vec![InstanceKey(0), InstanceKey(1), InstanceKey(2)], None);
         let points = Point2D::to_arrow(points, None);
-        let colors = ColorRGBA::to_arrow(colors, None);
+        let colors = Color::to_arrow(colors, None);
 
         DataFrame::new(vec![
             Series::try_from((InstanceKey::name().as_ref(), instances)).unwrap(),
             Series::try_from((Point2D::name().as_ref(), points)).unwrap(),
-            Series::try_from((ColorRGBA::name().as_ref(), colors)).unwrap(),
+            Series::try_from((Color::name().as_ref(), colors)).unwrap(),
         ])
         .unwrap()
     };
diff --git a/crates/re_arrow_store/tests/data_store.rs b/crates/re_arrow_store/tests/data_store.rs
index 1413eb028c37..056fd63a8fc6 100644
--- a/crates/re_arrow_store/tests/data_store.rs
+++ b/crates/re_arrow_store/tests/data_store.rs
@@ -19,10 +19,13 @@ use re_components::{
         build_frame_nr, build_some_colors, build_some_instances, build_some_instances_from,
         build_some_point2d, build_some_rects,
     },
-    ColorRGBA, InstanceKey, Point2D, Rect2D,
+    Rect2D,
 };
 use re_log_types::{DataCell, DataRow, DataTable, EntityPath, TableId, TimeType, Timeline};
-use re_types::{ComponentName, Loggable as _};
+use re_types::{
+    components::{Color, InstanceKey, Point2D},
+    ComponentName, Loggable as _,
+};
 
 // --- LatestComponentsAt ---
 
@@ -87,16 +90,16 @@ fn all_components() {
         let cluster_key = store.cluster_key();
 
         let components_a = &[
-            ColorRGBA::name(), // added by test, timeless
-            Rect2D::name(),    // added by test
-            cluster_key,       // always here
+            Color::name(),  // added by test, timeless
+            Rect2D::name(), // added by test
+            cluster_key,    // always here
         ];
 
         let components_b = &[
-            ColorRGBA::name(), // added by test, timeless
-            Point2D::name(),   // added by test
-            Rect2D::name(),    // added by test
-            cluster_key,       // always here
+            Color::name(),   // added by test, timeless
+            Point2D::name(), // added by test
+            Rect2D::name(),  // added by test
+            cluster_key,     // always here
         ];
 
         let row = test_row!(ent_path @ [] => 2; [build_some_colors(2)]);
@@ -142,16 +145,16 @@ fn all_components() {
         // └──────────┴────────┴─────────┴────────┴───────────┴──────────┘
 
         let components_a = &[
-            ColorRGBA::name(), // added by test, timeless
-            Rect2D::name(),    // added by test
-            cluster_key,       // always here
+            Color::name(),  // added by test, timeless
+            Rect2D::name(), // added by test
+            cluster_key,    // always here
         ];
 
         let components_b = &[
-            ColorRGBA::name(), // added by test, timeless
-            Rect2D::name(),    // ⚠ inherited before the buckets got split apart!
-            Point2D::name(),   // added by test
-            cluster_key,       // always here
+            Color::name(),   // added by test, timeless
+            Rect2D::name(),  // ⚠ inherited before the buckets got split apart!
+            Point2D::name(), // added by test
+            cluster_key,     // always here
         ];
 
         let row = test_row!(ent_path @ [] => 2; [build_some_colors(2)]);
@@ -203,16 +206,16 @@ fn all_components() {
         // └──────────┴────────┴────────┴───────────┴──────────┘
 
         let components_a = &[
-            ColorRGBA::name(), // added by test, timeless
-            Rect2D::name(),    // added by test
-            cluster_key,       // always here
+            Color::name(),  // added by test, timeless
+            Rect2D::name(), // added by test
+            cluster_key,    // always here
         ];
 
         let components_b = &[
-            ColorRGBA::name(), // added by test, timeless
-            Point2D::name(),   // added by test but not contained in the second bucket
-            Rect2D::name(),    // added by test
-            cluster_key,       // always here
+            Color::name(),   // added by test, timeless
+            Point2D::name(), // added by test but not contained in the second bucket
+            Rect2D::name(),  // added by test
+            cluster_key,     // always here
         ];
 
         let row = test_row!(ent_path @ [] => 2; [build_some_colors(2)]);
@@ -312,7 +315,7 @@ fn latest_at_impl(store: &mut DataStore) {
 
     let mut assert_latest_components = |frame_nr: TimeInt, rows: &[(ComponentName, &DataRow)]| {
         let timeline_frame_nr = Timeline::new("frame_nr", TimeType::Sequence);
-        let components_all = &[ColorRGBA::name(), Point2D::name()];
+        let components_all = &[Color::name(), Point2D::name()];
 
         let df = polars_util::latest_components(
             &store,
@@ -333,27 +336,18 @@ fn latest_at_impl(store: &mut DataStore) {
 
     assert_latest_components(
         frame0,
-        &[(ColorRGBA::name(), &row4), (Point2D::name(), &row3)], // timeless
+        &[(Color::name(), &row4), (Point2D::name(), &row3)], // timeless
     );
     assert_latest_components(
         frame1,
         &[
-            (ColorRGBA::name(), &row1),
+            (Color::name(), &row1),
             (Point2D::name(), &row3), // timeless
         ],
     );
-    assert_latest_components(
-        frame2,
-        &[(ColorRGBA::name(), &row1), (Point2D::name(), &row2)],
-    );
-    assert_latest_components(
-        frame3,
-        &[(ColorRGBA::name(), &row1), (Point2D::name(), &row3)],
-    );
-    assert_latest_components(
-        frame4,
-        &[(ColorRGBA::name(), &row4), (Point2D::name(), &row3)],
-    );
+    assert_latest_components(frame2, &[(Color::name(), &row1), (Point2D::name(), &row2)]);
+    assert_latest_components(frame3, &[(Color::name(), &row1), (Point2D::name(), &row3)]);
+    assert_latest_components(frame4, &[(Color::name(), &row4), (Point2D::name(), &row3)]);
 }
 
 // --- Range ---
@@ -503,20 +497,20 @@ fn range_impl(store: &mut DataStore) {
 
     // TODO(cmc): bring back some log_time scenarios
 
-    // Unit ranges (ColorRGBA's PoV)
+    // Unit ranges (Color's PoV)
 
     assert_range_components(
         TimeRange::new(frame1, frame1),
-        [ColorRGBA::name(), Point2D::name()],
+        [Color::name(), Point2D::name()],
         &[
             (
                 Some(frame0),
-                &[(ColorRGBA::name(), &row4_3), (Point2D::name(), &row4_4)],
+                &[(Color::name(), &row4_3), (Point2D::name(), &row4_4)],
             ), // timeless
             (
                 Some(frame1),
                 &[
-                    (ColorRGBA::name(), &row1),
+                    (Color::name(), &row1),
                     (Point2D::name(), &row4_4), // timeless
                 ],
             ),
@@ -524,12 +518,12 @@ fn range_impl(store: &mut DataStore) {
     );
     assert_range_components(
         TimeRange::new(frame2, frame2),
-        [ColorRGBA::name(), Point2D::name()],
+        [Color::name(), Point2D::name()],
         &[
             (
                 Some(frame1),
                 &[
-                    (ColorRGBA::name(), &row1),
+                    (Color::name(), &row1),
                     (Point2D::name(), &row4_4), // timeless
                 ],
             ), //
@@ -537,43 +531,43 @@ fn range_impl(store: &mut DataStore) {
     );
     assert_range_components(
         TimeRange::new(frame3, frame3),
-        [ColorRGBA::name(), Point2D::name()],
+        [Color::name(), Point2D::name()],
         &[
             (
                 Some(frame2),
-                &[(ColorRGBA::name(), &row1), (Point2D::name(), &row2)],
+                &[(Color::name(), &row1), (Point2D::name(), &row2)],
             ), //
         ],
     );
     assert_range_components(
         TimeRange::new(frame4, frame4),
-        [ColorRGBA::name(), Point2D::name()],
+        [Color::name(), Point2D::name()],
         &[
             (
                 Some(frame3),
-                &[(ColorRGBA::name(), &row1), (Point2D::name(), &row3)],
+                &[(Color::name(), &row1), (Point2D::name(), &row3)],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_1), (Point2D::name(), &row3)],
+                &[(Color::name(), &row4_1), (Point2D::name(), &row3)],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_2), (Point2D::name(), &row3)],
+                &[(Color::name(), &row4_2), (Point2D::name(), &row3)],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
+                &[(Color::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
             ),
         ],
     );
     assert_range_components(
         TimeRange::new(frame5, frame5),
-        [ColorRGBA::name(), Point2D::name()],
+        [Color::name(), Point2D::name()],
         &[
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_3), (Point2D::name(), &row4_4)], // !!!
+                &[(Color::name(), &row4_3), (Point2D::name(), &row4_4)], // !!!
             ), //
         ],
     );
@@ -582,102 +576,102 @@ fn range_impl(store: &mut DataStore) {
 
     assert_range_components(
         TimeRange::new(frame1, frame1),
-        [Point2D::name(), ColorRGBA::name()],
+        [Point2D::name(), Color::name()],
         &[
             (
                 Some(frame0),
-                &[(Point2D::name(), &row4_4), (ColorRGBA::name(), &row4_3)],
+                &[(Point2D::name(), &row4_4), (Color::name(), &row4_3)],
             ), // timeless
         ],
     );
     assert_range_components(
         TimeRange::new(frame2, frame2),
-        [Point2D::name(), ColorRGBA::name()],
+        [Point2D::name(), Color::name()],
         &[
             (
                 Some(frame1),
                 &[
                     (Point2D::name(), &row4_4), // timeless
-                    (ColorRGBA::name(), &row1),
+                    (Color::name(), &row1),
                 ],
             ),
             (
                 Some(frame2),
-                &[(Point2D::name(), &row2), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row2), (Color::name(), &row1)],
             ), //
         ],
     );
     assert_range_components(
         TimeRange::new(frame3, frame3),
-        [Point2D::name(), ColorRGBA::name()],
+        [Point2D::name(), Color::name()],
         &[
             (
                 Some(frame2),
-                &[(Point2D::name(), &row2), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row2), (Color::name(), &row1)],
             ),
             (
                 Some(frame3),
-                &[(Point2D::name(), &row3), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row3), (Color::name(), &row1)],
             ),
         ],
     );
     assert_range_components(
         TimeRange::new(frame4, frame4),
-        [Point2D::name(), ColorRGBA::name()],
+        [Point2D::name(), Color::name()],
         &[
             (
                 Some(frame3),
-                &[(Point2D::name(), &row3), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row3), (Color::name(), &row1)],
             ),
             (
                 Some(frame4),
-                &[(Point2D::name(), &row4_25), (ColorRGBA::name(), &row4_2)],
+                &[(Point2D::name(), &row4_25), (Color::name(), &row4_2)],
             ),
             (
                 Some(frame4),
-                &[(Point2D::name(), &row4_4), (ColorRGBA::name(), &row4_3)],
+                &[(Point2D::name(), &row4_4), (Color::name(), &row4_3)],
             ),
         ],
     );
     assert_range_components(
         TimeRange::new(frame5, frame5),
-        [Point2D::name(), ColorRGBA::name()],
+        [Point2D::name(), Color::name()],
         &[
             (
                 Some(frame4),
-                &[(Point2D::name(), &row4_4), (ColorRGBA::name(), &row4_3)],
+                &[(Point2D::name(), &row4_4), (Color::name(), &row4_3)],
             ), //
         ],
     );
 
-    // Full range (ColorRGBA's PoV)
+    // Full range (Color's PoV)
 
     assert_range_components(
         TimeRange::new(frame1, frame5),
-        [ColorRGBA::name(), Point2D::name()],
+        [Color::name(), Point2D::name()],
         &[
             (
                 Some(frame0),
-                &[(ColorRGBA::name(), &row4_3), (Point2D::name(), &row4_4)],
+                &[(Color::name(), &row4_3), (Point2D::name(), &row4_4)],
             ), // timeless
             (
                 Some(frame1),
                 &[
-                    (ColorRGBA::name(), &row1),
+                    (Color::name(), &row1),
                     (Point2D::name(), &row4_4), // timeless
                 ],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_1), (Point2D::name(), &row3)],
+                &[(Color::name(), &row4_1), (Point2D::name(), &row3)],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_2), (Point2D::name(), &row3)],
+                &[(Color::name(), &row4_2), (Point2D::name(), &row3)],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
+                &[(Color::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
             ),
         ],
     );
@@ -686,68 +680,62 @@ fn range_impl(store: &mut DataStore) {
 
     assert_range_components(
         TimeRange::new(frame1, frame5),
-        [Point2D::name(), ColorRGBA::name()],
+        [Point2D::name(), Color::name()],
         &[
             (
                 Some(frame0),
-                &[(Point2D::name(), &row4_4), (ColorRGBA::name(), &row4_3)],
+                &[(Point2D::name(), &row4_4), (Color::name(), &row4_3)],
             ), // timeless
             (
                 Some(frame2),
-                &[(Point2D::name(), &row2), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row2), (Color::name(), &row1)],
             ),
             (
                 Some(frame3),
-                &[(Point2D::name(), &row3), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row3), (Color::name(), &row1)],
             ),
             (
                 Some(frame4),
-                &[(Point2D::name(), &row4_25), (ColorRGBA::name(), &row4_2)],
+                &[(Point2D::name(), &row4_25), (Color::name(), &row4_2)],
             ),
             (
                 Some(frame4),
-                &[(Point2D::name(), &row4_4), (ColorRGBA::name(), &row4_3)],
+                &[(Point2D::name(), &row4_4), (Color::name(), &row4_3)],
             ),
         ],
     );
 
-    // Infinite range (ColorRGBA's PoV)
+    // Infinite range (Color's PoV)
 
     assert_range_components(
         TimeRange::new(TimeInt::MIN, TimeInt::MAX),
-        [ColorRGBA::name(), Point2D::name()],
+        [Color::name(), Point2D::name()],
         &[
-            (None, &[(ColorRGBA::name(), &row1)]),
-            (
-                None,
-                &[(ColorRGBA::name(), &row4_1), (Point2D::name(), &row3)],
-            ),
+            (None, &[(Color::name(), &row1)]),
+            (None, &[(Color::name(), &row4_1), (Point2D::name(), &row3)]),
+            (None, &[(Color::name(), &row4_2), (Point2D::name(), &row3)]),
             (
                 None,
-                &[(ColorRGBA::name(), &row4_2), (Point2D::name(), &row3)],
-            ),
-            (
-                None,
-                &[(ColorRGBA::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
+                &[(Color::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
             ),
             (
                 Some(frame1),
                 &[
-                    (ColorRGBA::name(), &row1),
+                    (Color::name(), &row1),
                     (Point2D::name(), &row4_4), // timeless
                 ],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_1), (Point2D::name(), &row3)],
+                &[(Color::name(), &row4_1), (Point2D::name(), &row3)],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_2), (Point2D::name(), &row3)],
+                &[(Color::name(), &row4_2), (Point2D::name(), &row3)],
             ),
             (
                 Some(frame4),
-                &[(ColorRGBA::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
+                &[(Color::name(), &row4_3), (Point2D::name(), &row4_25)], // !!!
             ),
         ],
     );
@@ -756,39 +744,33 @@ fn range_impl(store: &mut DataStore) {
 
     assert_range_components(
         TimeRange::new(TimeInt::MIN, TimeInt::MAX),
-        [Point2D::name(), ColorRGBA::name()],
+        [Point2D::name(), Color::name()],
         &[
+            (None, &[(Point2D::name(), &row2), (Color::name(), &row1)]),
+            (None, &[(Point2D::name(), &row3), (Color::name(), &row1)]),
             (
                 None,
-                &[(Point2D::name(), &row2), (ColorRGBA::name(), &row1)],
-            ),
-            (
-                None,
-                &[(Point2D::name(), &row3), (ColorRGBA::name(), &row1)],
-            ),
-            (
-                None,
-                &[(Point2D::name(), &row4_25), (ColorRGBA::name(), &row4_2)],
+                &[(Point2D::name(), &row4_25), (Color::name(), &row4_2)],
             ),
             (
                 None,
-                &[(Point2D::name(), &row4_4), (ColorRGBA::name(), &row4_3)],
+                &[(Point2D::name(), &row4_4), (Color::name(), &row4_3)],
             ),
             (
                 Some(frame2),
-                &[(Point2D::name(), &row2), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row2), (Color::name(), &row1)],
             ),
             (
                 Some(frame3),
-                &[(Point2D::name(), &row3), (ColorRGBA::name(), &row1)],
+                &[(Point2D::name(), &row3), (Color::name(), &row1)],
             ),
             (
                 Some(frame4),
-                &[(Point2D::name(), &row4_25), (ColorRGBA::name(), &row4_2)],
+                &[(Point2D::name(), &row4_25), (Color::name(), &row4_2)],
             ),
             (
                 Some(frame4),
-                &[(Point2D::name(), &row4_4), (ColorRGBA::name(), &row4_3)],
+                &[(Point2D::name(), &row4_4), (Color::name(), &row4_3)],
             ),
         ],
     );
diff --git a/crates/re_components/src/class_id.rs b/crates/re_components/src/class_id.rs
index ee40da03ef28..e92676312889 100644
--- a/crates/re_components/src/class_id.rs
+++ b/crates/re_components/src/class_id.rs
@@ -19,19 +19,25 @@ use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
     ArrowDeserialize,
 )]
 #[arrow_field(transparent)]
-pub struct ClassId(pub u16);
+pub struct LegacyClassId(pub u16);
 
-impl re_log_types::LegacyComponent for ClassId {
+impl From<LegacyClassId> for re_types::components::ClassId {
+    fn from(val: LegacyClassId) -> Self {
+        re_types::components::ClassId(val.0)
+    }
+}
+
+impl re_log_types::LegacyComponent for LegacyClassId {
     #[inline]
     fn legacy_name() -> re_log_types::ComponentName {
         "rerun.class_id".into()
     }
 }
 
-impl From<re_types::components::ClassId> for ClassId {
+impl From<re_types::components::ClassId> for LegacyClassId {
     fn from(other: re_types::components::ClassId) -> Self {
         Self(other.0)
     }
 }
 
-re_log_types::component_legacy_shim!(ClassId);
+re_log_types::component_legacy_shim!(LegacyClassId);
diff --git a/crates/re_components/src/color.rs b/crates/re_components/src/color.rs
index 92884d5e730b..7cde9e8d9400 100644
--- a/crates/re_components/src/color.rs
+++ b/crates/re_components/src/color.rs
@@ -1,13 +1,5 @@
 /// An RGBA color tuple with unmultiplied/separate alpha,
 /// in sRGB gamma space with linear alpha.
-///
-/// ```
-/// use re_components::ColorRGBA;
-/// use arrow2_convert::field::ArrowField;
-/// use arrow2::datatypes::{DataType, Field};
-///
-/// assert_eq!(ColorRGBA::data_type(), DataType::UInt32);
-/// ```
 #[derive(
     Clone,
     Copy,
@@ -23,9 +15,21 @@
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[arrow_field(transparent)]
 #[repr(transparent)]
-pub struct ColorRGBA(pub u32);
+pub struct LegacyColor(pub u32);
 
-impl ColorRGBA {
+impl From<LegacyColor> for re_types::components::Color {
+    fn from(val: LegacyColor) -> Self {
+        re_types::components::Color(val.0)
+    }
+}
+
+impl From<re_types::components::Color> for LegacyColor {
+    fn from(val: re_types::components::Color) -> Self {
+        LegacyColor(val.0)
+    }
+}
+
+impl LegacyColor {
     #[inline]
     pub fn from_rgb(r: u8, g: u8, b: u8) -> Self {
         Self::from([r, g, b, 255])
@@ -47,7 +51,7 @@ impl ColorRGBA {
     }
 }
 
-impl From<[u8; 4]> for ColorRGBA {
+impl From<[u8; 4]> for LegacyColor {
     #[inline]
     fn from(bytes: [u8; 4]) -> Self {
         Self(
@@ -59,7 +63,7 @@ impl From<[u8; 4]> for ColorRGBA {
     }
 }
 
-impl re_log_types::LegacyComponent for ColorRGBA {
+impl re_log_types::LegacyComponent for LegacyColor {
     #[inline]
     fn legacy_name() -> re_log_types::ComponentName {
         "rerun.colorrgba".into()
@@ -67,22 +71,22 @@ impl re_log_types::LegacyComponent for ColorRGBA {
 }
 
 #[cfg(feature = "ecolor")]
-impl From<ColorRGBA> for ecolor::Color32 {
-    fn from(color: ColorRGBA) -> Self {
+impl From<LegacyColor> for ecolor::Color32 {
+    fn from(color: LegacyColor) -> Self {
         let [r, g, b, a] = color.to_array();
         Self::from_rgba_premultiplied(r, g, b, a)
     }
 }
 
-re_log_types::component_legacy_shim!(ColorRGBA);
+re_log_types::component_legacy_shim!(LegacyColor);
 
 #[test]
 fn test_colorrgba_roundtrip() {
     use arrow2::array::Array;
     use arrow2_convert::{deserialize::TryIntoCollection, serialize::TryIntoArrow};
 
-    let colors_in = vec![ColorRGBA(0u32), ColorRGBA(255u32)];
+    let colors_in = vec![LegacyColor(0u32), LegacyColor(255u32)];
     let array: Box<dyn Array> = colors_in.try_into_arrow().unwrap();
-    let colors_out: Vec<ColorRGBA> = TryIntoCollection::try_into_collection(array).unwrap();
+    let colors_out: Vec<LegacyColor> = TryIntoCollection::try_into_collection(array).unwrap();
     assert_eq!(colors_in, colors_out);
 }
diff --git a/crates/re_components/src/context.rs b/crates/re_components/src/context.rs
index 287e34207e7b..2f160716022b 100644
--- a/crates/re_components/src/context.rs
+++ b/crates/re_components/src/context.rs
@@ -4,8 +4,9 @@ use arrow2_convert::{
     deserialize::ArrowDeserialize, field::ArrowField, serialize::ArrowSerialize, ArrowDeserialize,
     ArrowField, ArrowSerialize,
 };
+use re_types::components::{ClassId, KeypointId};
 
-use crate::{ClassId, ColorRGBA, KeypointId, Label};
+use crate::{LegacyClassId, LegacyColor, LegacyKeypointId, LegacyLabel};
 
 /// Information about an Annotation.
 ///
@@ -15,8 +16,8 @@ use crate::{ClassId, ColorRGBA, KeypointId, Label};
 pub struct AnnotationInfo {
     /// [`ClassId`] or [`KeypointId`] to which this annotation info belongs.
     pub id: u16,
-    pub label: Option<Label>,
-    pub color: Option<ColorRGBA>,
+    pub label: Option<LegacyLabel>,
+    pub color: Option<LegacyColor>,
 }
 
 /// The description of a semantic Class.
@@ -49,8 +50,8 @@ pub struct ClassDescription {
 /// Helper struct for converting `ClassDescription` to arrow
 #[derive(ArrowField, ArrowSerialize, ArrowDeserialize)]
 struct KeypointPairArrow {
-    keypoint0: KeypointId,
-    keypoint1: KeypointId,
+    keypoint0: LegacyKeypointId,
+    keypoint1: LegacyKeypointId,
 }
 
 /// Helper struct for converting `ClassDescription` to arrow
@@ -70,8 +71,8 @@ impl From<&ClassDescription> for ClassDescriptionArrow {
                 .keypoint_connections
                 .iter()
                 .map(|(k0, k1)| KeypointPairArrow {
-                    keypoint0: *k0,
-                    keypoint1: *k1,
+                    keypoint0: (*k0).into(),
+                    keypoint1: (*k1).into(),
                 })
                 .collect(),
         }
@@ -90,7 +91,7 @@ impl From<ClassDescriptionArrow> for ClassDescription {
             keypoint_connections: v
                 .keypoint_connections
                 .into_iter()
-                .map(|elem| (elem.keypoint0, elem.keypoint1))
+                .map(|elem| (elem.keypoint0.into(), elem.keypoint1.into()))
                 .collect(),
         }
     }
@@ -177,7 +178,7 @@ impl re_log_types::LegacyComponent for AnnotationContext {
 /// Helper struct for converting `AnnotationContext` to arrow
 #[derive(ArrowField, ArrowSerialize, ArrowDeserialize)]
 pub struct ClassMapElemArrow {
-    class_id: ClassId,
+    class_id: LegacyClassId,
     class_description: ClassDescriptionArrow,
 }
 
@@ -189,7 +190,7 @@ impl From<&AnnotationContext> for AnnotationContextArrow {
         v.class_map
             .iter()
             .map(|(class_id, class_description)| ClassMapElemArrow {
-                class_id: *class_id,
+                class_id: (*class_id).into(),
                 class_description: class_description.into(),
             })
             .collect()
@@ -202,7 +203,7 @@ impl From<Vec<ClassMapElemArrow>> for AnnotationContext {
         AnnotationContext {
             class_map: v
                 .into_iter()
-                .map(|elem| (elem.class_id, elem.class_description.into()))
+                .map(|elem| (elem.class_id.into(), elem.class_description.into()))
                 .collect(),
         }
     }
@@ -258,15 +259,15 @@ fn test_context_roundtrip() {
             ClassDescription {
                 info: AnnotationInfo {
                     id: 32,
-                    label: Some(Label("hello".to_owned())),
-                    color: Some(ColorRGBA(0x123456)),
+                    label: Some(LegacyLabel("hello".to_owned())),
+                    color: Some(LegacyColor(0x123456)),
                 },
                 keypoint_map: vec![
                     (
                         KeypointId(43),
                         AnnotationInfo {
                             id: 43,
-                            label: Some(Label("head".to_owned())),
+                            label: Some(LegacyLabel("head".to_owned())),
                             color: None,
                         },
                     ),
@@ -274,8 +275,8 @@ fn test_context_roundtrip() {
                         KeypointId(94),
                         AnnotationInfo {
                             id: 94,
-                            label: Some(Label("leg".to_owned())),
-                            color: Some(ColorRGBA(0x654321)),
+                            label: Some(LegacyLabel("leg".to_owned())),
+                            color: Some(LegacyColor(0x654321)),
                         },
                     ),
                 ]
diff --git a/crates/re_components/src/datagen.rs b/crates/re_components/src/datagen.rs
index acbf203dc1e5..178b6c283f9f 100644
--- a/crates/re_components/src/datagen.rs
+++ b/crates/re_components/src/datagen.rs
@@ -13,8 +13,10 @@ pub fn build_some_rects(len: usize) -> Vec<crate::Rect2D> {
 }
 
 /// Create `len` dummy colors
-pub fn build_some_colors(len: usize) -> Vec<crate::ColorRGBA> {
-    (0..len).map(|i| crate::ColorRGBA(i as u32)).collect()
+pub fn build_some_colors(len: usize) -> Vec<re_types::components::Color> {
+    (0..len)
+        .map(|i| re_types::components::Color(i as u32))
+        .collect()
 }
 
 /// Create `len` dummy labels
@@ -28,10 +30,7 @@ pub fn build_some_point2d(len: usize) -> Vec<crate::Point2D> {
     let mut rng = rand::thread_rng();
 
     (0..len)
-        .map(|_| crate::Point2D {
-            x: rng.gen_range(0.0..10.0),
-            y: rng.gen_range(0.0..10.0),
-        })
+        .map(|_| crate::Point2D::new(rng.gen_range(0.0..10.0), rng.gen_range(0.0..10.0)))
         .collect()
 }
 
@@ -87,7 +86,7 @@ pub fn build_some_instances_from(instances: impl IntoIterator<Item = u64>) -> Ve
 /// Crafts a simple but interesting [`re_log_types::DataTable`].
 #[cfg(not(target_arch = "wasm32"))]
 pub fn data_table_example(timeless: bool) -> re_log_types::DataTable {
-    use crate::{ColorRGBA, Label, Point2D};
+    use crate::{LegacyColor, LegacyLabel, Point2D};
     use re_log_types::{DataRow, DataTable, RowId, TableId, TimePoint};
 
     let table_id = TableId::random();
@@ -110,8 +109,8 @@ pub fn data_table_example(timeless: bool) -> re_log_types::DataTable {
     let row0 = {
         let num_instances = 2;
         let points: &[Point2D] = &[[10.0, 10.0].into(), [20.0, 20.0].into()];
-        let colors: &[_] = &[ColorRGBA::from_rgb(128, 128, 128)];
-        let labels: &[Label] = &[];
+        let colors: &[_] = &[LegacyColor::from_rgb(128, 128, 128)];
+        let labels: &[LegacyLabel] = &[];
 
         DataRow::from_cells3(
             RowId::random(),
@@ -124,15 +123,15 @@ pub fn data_table_example(timeless: bool) -> re_log_types::DataTable {
 
     let row1 = {
         let num_instances = 0;
-        let colors: &[ColorRGBA] = &[];
+        let colors: &[LegacyColor] = &[];
 
         DataRow::from_cells1(RowId::random(), "b", timepoint(1), num_instances, colors)
     };
 
     let row2 = {
         let num_instances = 1;
-        let colors: &[_] = &[ColorRGBA::from_rgb(255, 255, 255)];
-        let labels: &[_] = &[Label("hey".into())];
+        let colors: &[_] = &[LegacyColor::from_rgb(255, 255, 255)];
+        let labels: &[_] = &[LegacyLabel("hey".into())];
 
         DataRow::from_cells2(
             RowId::random(),
diff --git a/crates/re_components/src/draw_order.rs b/crates/re_components/src/draw_order.rs
deleted file mode 100644
index 2f0247e92f3b..000000000000
--- a/crates/re_components/src/draw_order.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
-
-/// Draw order used for the display order of 2D elements.
-///
-/// Higher values are drawn on top of lower values.
-/// An entity can have only a single draw order component.
-/// 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.
-///
-/// This component is a "mono-component". See [the crate level docs](crate) for details.
-///
-/// ```
-/// use re_components::DrawOrder;
-/// use arrow2_convert::field::ArrowField;
-/// use arrow2::datatypes::{DataType, Field};
-///
-/// assert_eq!(DrawOrder::data_type(), DataType::Float32);
-/// ```
-#[derive(Debug, Clone, Copy, ArrowField, ArrowSerialize, ArrowDeserialize)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[arrow_field(transparent)]
-pub struct DrawOrder(pub f32);
-
-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 re_log_types::LegacyComponent for DrawOrder {
-    #[inline]
-    fn legacy_name() -> re_log_types::ComponentName {
-        "rerun.draw_order".into()
-    }
-}
-
-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
-    }
-}
-
-re_log_types::component_legacy_shim!(DrawOrder);
diff --git a/crates/re_components/src/keypoint_id.rs b/crates/re_components/src/keypoint_id.rs
index b4e448b9bf22..79713166f965 100644
--- a/crates/re_components/src/keypoint_id.rs
+++ b/crates/re_components/src/keypoint_id.rs
@@ -21,19 +21,25 @@ use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
     ArrowDeserialize,
 )]
 #[arrow_field(transparent)]
-pub struct KeypointId(pub u16);
+pub struct LegacyKeypointId(pub u16);
 
-impl re_log_types::LegacyComponent for KeypointId {
+impl From<LegacyKeypointId> for re_types::components::KeypointId {
+    fn from(val: LegacyKeypointId) -> Self {
+        re_types::components::KeypointId(val.0)
+    }
+}
+
+impl re_log_types::LegacyComponent for LegacyKeypointId {
     #[inline]
     fn legacy_name() -> re_log_types::ComponentName {
         "rerun.keypoint_id".into()
     }
 }
 
-impl From<re_types::components::KeypointId> for KeypointId {
+impl From<re_types::components::KeypointId> for LegacyKeypointId {
     fn from(other: re_types::components::KeypointId) -> Self {
         Self(other.0)
     }
 }
 
-re_log_types::component_legacy_shim!(KeypointId);
+re_log_types::component_legacy_shim!(LegacyKeypointId);
diff --git a/crates/re_components/src/label.rs b/crates/re_components/src/label.rs
index 38aea0d5ecf9..7301e373eb96 100644
--- a/crates/re_components/src/label.rs
+++ b/crates/re_components/src/label.rs
@@ -1,62 +1,73 @@
 use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
 
 /// A String label component
-///
-/// ```
-/// use re_components::Label;
-/// use arrow2_convert::field::ArrowField;
-/// use arrow2::datatypes::{DataType, Field};
-///
-/// assert_eq!(Label::data_type(), DataType::Utf8);
-/// ```
 #[derive(Debug, Clone, PartialEq, Eq, ArrowField, ArrowSerialize, ArrowDeserialize)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[arrow_field(transparent)]
-pub struct Label(pub String);
+pub struct LegacyLabel(pub String);
 
-impl Label {
+impl From<LegacyLabel> for re_types::components::Label {
+    fn from(val: LegacyLabel) -> Self {
+        re_types::components::Label(val.0)
+    }
+}
+
+impl From<re_types::components::Label> for LegacyLabel {
+    fn from(value: re_types::components::Label) -> Self {
+        Self(value.0)
+    }
+}
+
+impl LegacyLabel {
     #[inline]
     pub fn as_str(&self) -> &str {
         self.0.as_str()
     }
 }
 
-impl re_log_types::LegacyComponent for Label {
+impl re_log_types::LegacyComponent for LegacyLabel {
     #[inline]
     fn legacy_name() -> re_log_types::ComponentName {
         "rerun.label".into()
     }
 }
 
-impl From<String> for Label {
+impl From<&str> for LegacyLabel {
+    #[inline]
+    fn from(value: &str) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<String> for LegacyLabel {
     #[inline]
     fn from(value: String) -> Self {
         Self(value)
     }
 }
 
-impl From<Label> for String {
+impl From<LegacyLabel> for String {
     #[inline]
-    fn from(value: Label) -> Self {
+    fn from(value: LegacyLabel) -> Self {
         value.0
     }
 }
 
-impl AsRef<str> for Label {
+impl AsRef<str> for LegacyLabel {
     #[inline]
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 
-impl std::borrow::Borrow<str> for Label {
+impl std::borrow::Borrow<str> for LegacyLabel {
     #[inline]
     fn borrow(&self) -> &str {
         self.as_str()
     }
 }
 
-impl std::ops::Deref for Label {
+impl std::ops::Deref for LegacyLabel {
     type Target = str;
     #[inline]
     fn deref(&self) -> &str {
@@ -64,4 +75,4 @@ impl std::ops::Deref for Label {
     }
 }
 
-re_log_types::component_legacy_shim!(Label);
+re_log_types::component_legacy_shim!(LegacyLabel);
diff --git a/crates/re_components/src/lib.rs b/crates/re_components/src/lib.rs
index 2caa9bac8001..159d5529e3ba 100644
--- a/crates/re_components/src/lib.rs
+++ b/crates/re_components/src/lib.rs
@@ -17,6 +17,7 @@ use arrow2_convert::{
     serialize::ArrowSerialize,
 };
 use lazy_static::lazy_static;
+use re_types::Loggable;
 
 mod arrow;
 mod bbox;
@@ -25,16 +26,13 @@ mod color;
 pub mod context;
 pub mod coordinates;
 mod disconnected_space;
-mod draw_order;
 mod keypoint_id;
 mod label;
 mod linestrip;
 mod mat;
 mod mesh3d;
 mod pinhole;
-mod point;
 mod quaternion;
-mod radius;
 mod rect;
 mod scalar;
 mod tensor;
@@ -53,24 +51,24 @@ pub mod datagen;
 // ----------------------------------------------------------------------------
 // TODO(emilk): split into modules, like we do in re_sdk/src/lib.rs
 
+// NOTE: We keep these legacy types around because they are used by the legacy `AnnotationContext`,
+// which needs them to implement `arrow2-convert`'s' traits.
+// TODO(#2794): get rid of this once `AnnotationContext` has been migrated.
+pub(crate) use self::{
+    class_id::LegacyClassId, color::LegacyColor, keypoint_id::LegacyKeypointId, label::LegacyLabel,
+};
+
 pub use self::{
     arrow::Arrow3D,
     bbox::Box3D,
-    class_id::ClassId,
-    color::ColorRGBA,
     context::{AnnotationContext, AnnotationInfo, ClassDescription},
     coordinates::ViewCoordinates,
     disconnected_space::DisconnectedSpace,
-    draw_order::DrawOrder,
-    keypoint_id::KeypointId,
-    label::Label,
     linestrip::{LineStrip2D, LineStrip3D},
     mat::Mat3x3,
     mesh3d::{EncodedMesh3D, Mesh3D, MeshFormat, MeshId, RawMesh3D},
     pinhole::Pinhole,
-    point::{Point2D, Point3D},
     quaternion::Quaternion,
-    radius::Radius,
     rect::Rect2D,
     scalar::{Scalar, ScalarPlotProps},
     tensor::{
@@ -93,9 +91,6 @@ pub use self::tensor::{TensorImageLoadError, TensorImageSaveError};
 #[cfg(not(target_arch = "wasm32"))]
 pub use self::load_file::{data_cell_from_file_path, data_cell_from_mesh_file_path, FromFileError};
 
-// This is a component
-pub use re_types::components::InstanceKey;
-
 // This is very convenient to re-export
 pub use re_log_types::LegacyComponent;
 
@@ -109,27 +104,22 @@ pub mod external {
 
 // ----------------------------------------------------------------------------
 
+use re_types::components::{
+    ClassId, Color, DrawOrder, InstanceKey, KeypointId, Label, Point2D, Point3D, Radius,
+};
+
 lazy_static! {
     //TODO(john): use a run-time type registry
     static ref FIELDS: [Field; 28] = [
         <AnnotationContext as LegacyComponent>::field(),
         <Arrow3D as LegacyComponent>::field(),
         <Box3D as LegacyComponent>::field(),
-        <ClassId as LegacyComponent>::field(),
-        <ColorRGBA as LegacyComponent>::field(),
-        <DrawOrder as LegacyComponent>::field(),
         <DisconnectedSpace as LegacyComponent>::field(),
-        <re_log_types::LegacyInstanceKey as LegacyComponent>::field(),
-        <KeypointId as LegacyComponent>::field(),
-        <Label as LegacyComponent>::field(),
         <LineStrip2D as LegacyComponent>::field(),
         <LineStrip3D as LegacyComponent>::field(),
         <Mesh3D as LegacyComponent>::field(),
         <Pinhole as LegacyComponent>::field(),
-        <Point2D as LegacyComponent>::field(),
-        <Point3D as LegacyComponent>::field(),
         <Quaternion as LegacyComponent>::field(),
-        <Radius as LegacyComponent>::field(),
         <Rect2D as LegacyComponent>::field(),
         <Scalar as LegacyComponent>::field(),
         <ScalarPlotProps as LegacyComponent>::field(),
@@ -140,6 +130,15 @@ lazy_static! {
         <Vec2D as LegacyComponent>::field(),
         <Vec3D as LegacyComponent>::field(),
         <ViewCoordinates as LegacyComponent>::field(),
+        Field::new(ClassId::name().as_str(), ClassId::to_arrow_datatype(), false),
+        Field::new(Color::name().as_str(), Color::to_arrow_datatype(), false),
+        Field::new(DrawOrder::name().as_str(), DrawOrder::to_arrow_datatype(), false),
+        Field::new(InstanceKey::name().as_str(), InstanceKey::to_arrow_datatype(), false),
+        Field::new(KeypointId::name().as_str(), KeypointId::to_arrow_datatype(), false),
+        Field::new(Label::name().as_str(), Label::to_arrow_datatype(), false),
+        Field::new(Point2D::name().as_str(), Point2D::to_arrow_datatype(), false),
+        Field::new(Point3D::name().as_str(), Point3D::to_arrow_datatype(), false),
+        Field::new(Radius::name().as_str(), Radius::to_arrow_datatype(), false),
     ];
 }
 
diff --git a/crates/re_components/src/mesh3d.rs b/crates/re_components/src/mesh3d.rs
index ee9f4e2a13a5..aeb5114c22cb 100644
--- a/crates/re_components/src/mesh3d.rs
+++ b/crates/re_components/src/mesh3d.rs
@@ -146,7 +146,7 @@ pub struct RawMesh3D {
     pub vertex_positions: Buffer<f32>,
 
     /// Per-vertex albedo colors.
-    /// This is actually an encoded [`super::ColorRGBA`]
+    /// This is actually an encoded [`super::Color`]
     pub vertex_colors: Option<Buffer<u32>>,
 
     /// Optionally, the flattened normals array for this mesh.
diff --git a/crates/re_components/src/point.rs b/crates/re_components/src/point.rs
deleted file mode 100644
index 956ec981bc7a..000000000000
--- a/crates/re_components/src/point.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
-
-// TODO(cmc): Points should just be containers of Vecs.
-
-/// A point in 2D space.
-///
-/// ```
-/// use re_components::Point2D;
-/// use arrow2_convert::field::ArrowField;
-/// use arrow2::datatypes::{DataType, Field};
-///
-/// assert_eq!(
-///     Point2D::data_type(),
-///     DataType::Struct(vec![
-///         Field::new("x", DataType::Float32, false),
-///         Field::new("y", DataType::Float32, false),
-///     ])
-/// );
-/// ```
-#[derive(Clone, Debug, ArrowField, ArrowSerialize, ArrowDeserialize, PartialEq)]
-pub struct Point2D {
-    pub x: f32,
-    pub y: f32,
-}
-
-impl Point2D {
-    pub const ZERO: Point2D = Point2D { x: 0.0, y: 0.0 };
-
-    #[inline]
-    pub fn new(x: f32, y: f32) -> Self {
-        Self { x, y }
-    }
-}
-
-impl re_log_types::LegacyComponent for Point2D {
-    #[inline]
-    fn legacy_name() -> re_log_types::ComponentName {
-        "rerun.point2d".into()
-    }
-}
-
-impl From<[f32; 2]> for Point2D {
-    #[inline]
-    fn from(p: [f32; 2]) -> Self {
-        Self { x: p[0], y: p[1] }
-    }
-}
-
-#[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)
-    }
-}
-
-re_log_types::component_legacy_shim!(Point2D);
-
-/// A point in 3D space.
-///
-/// ```
-/// use re_components::Point3D;
-/// use arrow2_convert::field::ArrowField;
-/// use arrow2::datatypes::{DataType, Field};
-///
-/// assert_eq!(
-///     Point3D::data_type(),
-///     DataType::Struct(vec![
-///         Field::new("x", DataType::Float32, false),
-///         Field::new("y", DataType::Float32, false),
-///         Field::new("z", DataType::Float32, false),
-///     ])
-/// );
-/// ```
-#[derive(Clone, Debug, ArrowField, ArrowSerialize, ArrowDeserialize, PartialEq)]
-pub struct Point3D {
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-}
-
-impl Point3D {
-    pub const ZERO: Point3D = Point3D {
-        x: 0.0,
-        y: 0.0,
-        z: 0.0,
-    };
-
-    #[inline]
-    pub fn new(x: f32, y: f32, z: f32) -> Self {
-        Self { x, y, z }
-    }
-}
-
-impl re_log_types::LegacyComponent for Point3D {
-    #[inline]
-    fn legacy_name() -> re_log_types::ComponentName {
-        "rerun.point3d".into()
-    }
-}
-
-impl From<[f32; 3]> for Point3D {
-    #[inline]
-    fn from(p: [f32; 3]) -> Self {
-        Self {
-            x: p[0],
-            y: p[1],
-            z: p[2],
-        }
-    }
-}
-
-#[cfg(feature = "glam")]
-impl From<glam::Vec3> for Point3D {
-    #[inline]
-    fn from(pt: glam::Vec3) -> Self {
-        Self::new(pt.x, pt.y, pt.z)
-    }
-}
-
-#[cfg(feature = "glam")]
-impl From<Point3D> for glam::Vec3 {
-    #[inline]
-    fn from(pt: Point3D) -> Self {
-        Self::new(pt.x, pt.y, pt.z)
-    }
-}
-
-re_log_types::component_legacy_shim!(Point3D);
diff --git a/crates/re_components/src/radius.rs b/crates/re_components/src/radius.rs
deleted file mode 100644
index faa7847b4f01..000000000000
--- a/crates/re_components/src/radius.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
-
-/// A Radius component
-///
-/// ## Examples
-///
-/// ```
-/// # use re_components::Radius;
-/// # use arrow2_convert::field::ArrowField;
-/// # use arrow2::datatypes::{DataType, Field};
-/// assert_eq!(Radius::data_type(), DataType::Float32);
-/// ```
-#[derive(Debug, Clone, Copy, ArrowField, ArrowSerialize, ArrowDeserialize)]
-#[arrow_field(transparent)]
-pub struct Radius(pub f32);
-
-impl re_log_types::LegacyComponent for Radius {
-    #[inline]
-    fn legacy_name() -> re_log_types::ComponentName {
-        "rerun.radius".into()
-    }
-}
-
-re_log_types::component_legacy_shim!(Radius);
diff --git a/crates/re_components/tests/data_row.rs b/crates/re_components/tests/data_row.rs
index 7171c573cea2..5870335a4bad 100644
--- a/crates/re_components/tests/data_row.rs
+++ b/crates/re_components/tests/data_row.rs
@@ -1,6 +1,8 @@
-use re_components::{ColorRGBA, Label, Point2D};
 use re_log_types::{DataRow, DataRowError, EntityPath, RowId, TimePoint};
-use re_types::Loggable as _;
+use re_types::{
+    components::{Color, Label, Point2D},
+    Loggable as _,
+};
 
 #[test]
 fn data_row_error_num_instances() {
@@ -9,7 +11,7 @@ fn data_row_error_num_instances() {
 
     let num_instances = 2;
     let points: &[Point2D] = &[[10.0, 10.0].into(), [20.0, 20.0].into()];
-    let colors: &[_] = &[ColorRGBA::from_rgb(128, 128, 128)];
+    let colors: &[_] = &[Color::from_rgb(128, 128, 128)];
     let labels: &[Label] = &[];
 
     // 0 = clear: legal
diff --git a/crates/re_components/tests/data_table.rs b/crates/re_components/tests/data_table.rs
index d5dde12d2367..e5fe39595caa 100644
--- a/crates/re_components/tests/data_table.rs
+++ b/crates/re_components/tests/data_table.rs
@@ -65,9 +65,9 @@ fn data_table_sizes_basics() {
     // utf8 (and more generally: dyn_binary)
     let mut cell = DataCell::from_native(
         [
-            re_components::Label("hey".into()),
-            re_components::Label("hey".into()),
-            re_components::Label("hey".into()),
+            re_types::components::Label("hey".into()),
+            re_types::components::Label("hey".into()),
+            re_types::components::Label("hey".into()),
         ]
         .as_slice(),
     );
@@ -78,7 +78,10 @@ fn data_table_sizes_basics() {
         3_090_064,    // expected_num_bytes
     );
     expect(
-        DataCell::from_arrow(re_components::Label::name(), cell.to_arrow().sliced(1, 1)),
+        DataCell::from_arrow(
+            re_types::components::Label::name(),
+            cell.to_arrow().sliced(1, 1),
+        ),
         10_000,    // num_rows
         2_950_064, // expected_num_bytes
     );
@@ -86,9 +89,9 @@ fn data_table_sizes_basics() {
     // struct
     let mut cell = DataCell::from_native(
         [
-            re_components::Point2D::new(42.0, 666.0),
-            re_components::Point2D::new(42.0, 666.0),
-            re_components::Point2D::new(42.0, 666.0),
+            re_types::components::Point2D::new(42.0, 666.0),
+            re_types::components::Point2D::new(42.0, 666.0),
+            re_types::components::Point2D::new(42.0, 666.0),
         ]
         .as_slice(),
     );
@@ -99,7 +102,10 @@ fn data_table_sizes_basics() {
         5_260_064,    // expected_num_bytes
     );
     expect(
-        DataCell::from_arrow(re_components::Point2D::name(), cell.to_arrow().sliced(1, 1)),
+        DataCell::from_arrow(
+            re_types::components::Point2D::name(),
+            cell.to_arrow().sliced(1, 1),
+        ),
         10_000,    // num_rows
         5_100_064, // expected_num_bytes
     );
@@ -120,7 +126,10 @@ fn data_table_sizes_basics() {
         4_080_064,    // expected_num_bytes
     );
     expect(
-        DataCell::from_arrow(re_components::Point2D::name(), cell.to_arrow().sliced(1, 1)),
+        DataCell::from_arrow(
+            re_types::components::Point2D::name(),
+            cell.to_arrow().sliced(1, 1),
+        ),
         10_000,    // num_rows
         3_920_064, // expected_num_bytes
     );
@@ -141,7 +150,10 @@ fn data_table_sizes_basics() {
         6_120_064,    // expected_num_bytes
     );
     expect(
-        DataCell::from_arrow(re_components::Point2D::name(), cell.to_arrow().sliced(1, 1)),
+        DataCell::from_arrow(
+            re_types::components::Point2D::name(),
+            cell.to_arrow().sliced(1, 1),
+        ),
         10_000,    // num_rows
         5_560_064, // expected_num_bytes
     );
diff --git a/crates/re_components/tests/data_table_batcher.rs b/crates/re_components/tests/data_table_batcher.rs
index 312694c25f12..e35bf67903d2 100644
--- a/crates/re_components/tests/data_table_batcher.rs
+++ b/crates/re_components/tests/data_table_batcher.rs
@@ -1,11 +1,11 @@
 use crossbeam::{channel::TryRecvError, select};
 use itertools::Itertools as _;
 
-use re_components::{ColorRGBA, Label, Point2D};
 use re_log_types::{
     DataRow, DataTableBatcher, DataTableBatcherConfig, RowId, SizeBytes, TimePoint, Timeline,
 };
 use re_log_types::{DataTable, TableId, Time};
+use re_types::components::{Color, Label, Point2D};
 
 #[test]
 fn manual_trigger() {
@@ -282,7 +282,7 @@ fn create_table() -> DataTable {
     let row0 = {
         let num_instances = 2;
         let points: &[Point2D] = &[[10.0, 10.0].into(), [20.0, 20.0].into()];
-        let colors: &[_] = &[ColorRGBA::from_rgb(128, 128, 128)];
+        let colors: &[_] = &[Color::from_rgb(128, 128, 128)];
         let labels: &[Label] = &[];
 
         DataRow::from_cells3(
@@ -296,14 +296,14 @@ fn create_table() -> DataTable {
 
     let row1 = {
         let num_instances = 0;
-        let colors: &[ColorRGBA] = &[];
+        let colors: &[Color] = &[];
 
         DataRow::from_cells1(RowId::random(), "b", timepoint(1), num_instances, colors)
     };
 
     let row2 = {
         let num_instances = 1;
-        let colors: &[_] = &[ColorRGBA::from_rgb(255, 255, 255)];
+        let colors: &[_] = &[Color::from_rgb(255, 255, 255)];
         let labels: &[_] = &[Label("hey".into())];
 
         DataRow::from_cells2(
diff --git a/crates/re_data_store/src/store_db.rs b/crates/re_data_store/src/store_db.rs
index 90735d0e362b..f219757f87c9 100644
--- a/crates/re_data_store/src/store_db.rs
+++ b/crates/re_data_store/src/store_db.rs
@@ -187,7 +187,11 @@ fn check_known_component_schemas(msg: &ArrowMsg) {
     for actual in &msg.schema.fields {
         if let Some(expected) = known_fields.get(actual.name.as_str()) {
             if let arrow2::datatypes::DataType::List(actual_field) = &actual.data_type {
-                if actual_field.data_type != expected.data_type {
+                // NOTE: Don't care about extensions until the migration is over (arrow2-convert
+                // issues).
+                let actual_datatype = actual_field.data_type.to_logical_type();
+                let expected_datatype = expected.data_type.to_logical_type();
+                if actual_datatype != expected_datatype {
                     re_log::warn_once!(
                         "The incoming component {:?} had the type:\n{:#?}\nExpected type:\n{:#?}",
                         actual.name,
diff --git a/crates/re_data_ui/src/annotation_context.rs b/crates/re_data_ui/src/annotation_context.rs
index 3dcc49afa2b4..3e7d92a8bf1a 100644
--- a/crates/re_data_ui/src/annotation_context.rs
+++ b/crates/re_data_ui/src/annotation_context.rs
@@ -1,14 +1,15 @@
 use egui::{color_picker, Vec2};
 use itertools::Itertools;
 
-use re_components::{AnnotationContext, AnnotationInfo, ClassId};
+use re_components::{AnnotationContext, AnnotationInfo};
+use re_types::components::ClassId;
 use re_viewer_context::{auto_color, UiVerbosity, ViewerContext};
 
 use super::DataUi;
 
 const TABLE_SCROLL_AREA_HEIGHT: f32 = 500.0; // add scroll-bars when we get to this height
 
-impl crate::EntityDataUi for re_components::ClassId {
+impl crate::EntityDataUi for ClassId {
     fn entity_data_ui(
         &self,
         ctx: &mut re_viewer_context::ViewerContext<'_>,
@@ -47,7 +48,7 @@ impl crate::EntityDataUi for re_components::ClassId {
     }
 }
 
-impl crate::EntityDataUi for re_components::KeypointId {
+impl crate::EntityDataUi for re_types::components::KeypointId {
     fn entity_data_ui(
         &self,
         ctx: &mut re_viewer_context::ViewerContext<'_>,
@@ -75,7 +76,7 @@ fn annotation_info(
     ctx: &mut re_viewer_context::ViewerContext<'_>,
     entity_path: &re_log_types::EntityPath,
     query: &re_arrow_store::LatestAtQuery,
-    keypoint_id: &re_components::KeypointId,
+    keypoint_id: &re_types::components::KeypointId,
 ) -> Option<re_components::AnnotationInfo> {
     let class_id = ctx
         .store_db
@@ -123,11 +124,7 @@ impl DataUi for AnnotationContext {
     }
 }
 
-fn class_description_ui(
-    ui: &mut egui::Ui,
-    class: &re_components::ClassDescription,
-    id: re_components::ClassId,
-) {
+fn class_description_ui(ui: &mut egui::Ui, class: &re_components::ClassDescription, id: ClassId) {
     if class.keypoint_connections.is_empty() && class.keypoint_map.is_empty() {
         return;
     }
diff --git a/crates/re_data_ui/src/component_ui_registry.rs b/crates/re_data_ui/src/component_ui_registry.rs
index d38b2b6d4565..5325734424a8 100644
--- a/crates/re_data_ui/src/component_ui_registry.rs
+++ b/crates/re_data_ui/src/component_ui_registry.rs
@@ -1,7 +1,6 @@
 use re_arrow_store::LatestAtQuery;
 use re_log_types::{external::arrow2, EntityPath};
 use re_query::ComponentWithInstances;
-use re_types::components::InstanceKey;
 use re_viewer_context::{ComponentUiRegistry, UiVerbosity, ViewerContext};
 
 use super::{DataUi, EntityDataUi};
@@ -37,16 +36,15 @@ pub fn create_component_ui_registry() -> ComponentUiRegistry {
     add::<re_components::AnnotationContext>(&mut registry);
     // add::<re_components::Arrow3D>(&mut registry);
     // add::<re_components::Box3D>(&mut registry);
-    add::<re_components::ClassId>(&mut registry);
-    add::<re_components::ColorRGBA>(&mut registry);
-    // add::<re_log_types::InstanceKey>(&mut registry);
-    add::<re_components::KeypointId>(&mut registry);
-    // add::<re_components::Label>(&mut registry);
+    add::<re_types::components::ClassId>(&mut registry);
+    add::<re_types::components::Color>(&mut registry);
+    add::<re_types::components::KeypointId>(&mut registry);
+    // add::<re_types::components::Label>(&mut registry);
     add::<re_components::LineStrip2D>(&mut registry);
     add::<re_components::LineStrip3D>(&mut registry);
     add::<re_components::Mesh3D>(&mut registry);
-    // add::<re_components::Point2D>(&mut registry);
-    // add::<re_components::Point3D>(&mut registry);
+    // add::<re_types::components::Point2D>(&mut registry);
+    // add::<re_types::components::Point3D>(&mut registry);
     add::<re_components::Pinhole>(&mut registry);
     // add::<re_components::Quaternion>(&mut registry);
     // add::<re_components::Radius>(&mut registry);
@@ -70,7 +68,7 @@ fn fallback_component_ui(
     _query: &LatestAtQuery,
     _entity_path: &EntityPath,
     component: &ComponentWithInstances,
-    instance_key: &InstanceKey,
+    instance_key: &re_types::components::InstanceKey,
 ) {
     // No special ui implementation - use a generic one:
     if let Some(value) = component.lookup_arrow(instance_key) {
diff --git a/crates/re_data_ui/src/data.rs b/crates/re_data_ui/src/data.rs
index b7cea1308991..9352de4d013d 100644
--- a/crates/re_data_ui/src/data.rs
+++ b/crates/re_data_ui/src/data.rs
@@ -1,9 +1,10 @@
 use egui::Vec2;
 
 use re_components::{
-    ColorRGBA, LineStrip2D, LineStrip3D, Mat3x3, Rect2D, Vec2D, Vec3D, Vec4D, ViewCoordinates,
+    LineStrip2D, LineStrip3D, Mat3x3, Rect2D, Vec2D, Vec3D, Vec4D, ViewCoordinates,
 };
 use re_format::format_f32;
+use re_types::components::Color;
 use re_viewer_context::{UiVerbosity, ViewerContext};
 
 use super::DataUi;
@@ -31,7 +32,7 @@ impl DataUi for [u8; 4] {
     }
 }
 
-impl DataUi for ColorRGBA {
+impl DataUi for Color {
     fn data_ui(
         &self,
         _ctx: &mut ViewerContext<'_>,
diff --git a/crates/re_data_ui/src/image.rs b/crates/re_data_ui/src/image.rs
index 48b363188656..d11dd61fcab2 100644
--- a/crates/re_data_ui/src/image.rs
+++ b/crates/re_data_ui/src/image.rs
@@ -1,8 +1,9 @@
 use egui::{Color32, Vec2};
 use itertools::Itertools as _;
 
-use re_components::{ClassId, DecodedTensor, Tensor, TensorDataMeaning, TensorElement};
+use re_components::{DecodedTensor, Tensor, TensorDataMeaning, TensorElement};
 use re_renderer::renderer::ColormappedTexture;
+use re_types::components::ClassId;
 use re_ui::ReUi;
 use re_viewer_context::{
     gpu_bridge, Annotations, TensorDecodeCache, TensorStats, TensorStatsCache, UiVerbosity,
diff --git a/crates/re_log_types/src/component.rs b/crates/re_log_types/src/component.rs
index 559ef7cedda2..32a13fe2c3fd 100644
--- a/crates/re_log_types/src/component.rs
+++ b/crates/re_log_types/src/component.rs
@@ -17,3 +17,14 @@ pub trait LegacyComponent: ArrowField {
         Field::new(Self::legacy_name().as_str(), Self::data_type(), false)
     }
 }
+
+// NOTE: We have a ton of legacy tests that rely on the old APIs and `Point2D`.
+// Since the new `Point2D` is binary compatible with the old we can easily drop the old one, but
+// for that we need the new one to implement the `LegacyComponent` trait.
+// TODO(cmc): remove once the migration is over
+impl LegacyComponent for re_types::components::Point2D {
+    fn legacy_name() -> ComponentName {
+        use re_types::Loggable as _;
+        Self::name()
+    }
+}
diff --git a/crates/re_log_types/src/instance_key.rs b/crates/re_log_types/src/instance_key.rs
deleted file mode 100644
index efc2a63862eb..000000000000
--- a/crates/re_log_types/src/instance_key.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
-
-use crate::LegacyComponent;
-
-/// A number used to specify a specific instance in an entity.
-///
-/// Each entity can have many component of the same type.
-/// These are identified with [`LegacyInstanceKey`].
-///
-/// This is a special component type. All entities has this component, at least implicitly.
-///
-/// For instance: A point cloud is one entity, and each point is an instance, idenitifed by an [`LegacyInstanceKey`].
-///
-/// ```
-/// use re_log_types::LegacyInstanceKey;
-/// use arrow2_convert::field::ArrowField;
-/// use arrow2::datatypes::{DataType, Field};
-///
-/// assert_eq!(LegacyInstanceKey::data_type(), DataType::UInt64);
-/// ```
-#[derive(
-    Copy,
-    Clone,
-    Default,
-    Hash,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    ArrowField,
-    ArrowSerialize,
-    ArrowDeserialize,
-)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[arrow_field(transparent)]
-pub struct LegacyInstanceKey(pub u64);
-
-impl LegacyInstanceKey {
-    /// A special value indicating that this [`LegacyInstanceKey]` is referring to all instances of an entity,
-    /// for example all points in a point cloud entity.
-    pub const SPLAT: Self = Self(u64::MAX);
-
-    #[allow(clippy::should_implement_trait)]
-    #[inline]
-    pub fn from_iter(it: impl IntoIterator<Item = impl Into<Self>>) -> Vec<Self> {
-        it.into_iter().map(Into::into).collect::<Vec<_>>()
-    }
-
-    /// Are we referring to all instances of the entity (e.g. all points in a point cloud entity)?
-    ///
-    /// The opposite of [`Self::is_specific`].
-    #[inline]
-    pub fn is_splat(self) -> bool {
-        self == Self::SPLAT
-    }
-
-    /// Are we referring to a specific instance of the entity (e.g. a specific point in a point cloud)?
-    ///
-    /// The opposite of [`Self::is_splat`].
-    #[inline]
-    pub fn is_specific(self) -> bool {
-        self != Self::SPLAT
-    }
-
-    /// Returns `None` if splat, otherwise the index.
-    #[inline]
-    pub fn specific_index(self) -> Option<LegacyInstanceKey> {
-        self.is_specific().then_some(self)
-    }
-
-    /// Creates a new [`LegacyInstanceKey`] that identifies a 2d coordinate.
-    pub fn from_2d_image_coordinate([x, y]: [u32; 2], image_width: u64) -> Self {
-        Self((x as u64) + (y as u64) * image_width)
-    }
-
-    /// Retrieves 2d image coordinates (x, y) encoded in an instance key
-    pub fn to_2d_image_coordinate(self, image_width: u64) -> [u32; 2] {
-        [(self.0 % image_width) as u32, (self.0 / image_width) as u32]
-    }
-}
-
-impl std::fmt::Debug for LegacyInstanceKey {
-    #[inline]
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.is_splat() {
-            "splat".fmt(f)
-        } else {
-            self.0.fmt(f)
-        }
-    }
-}
-
-impl std::fmt::Display for LegacyInstanceKey {
-    #[inline]
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.is_splat() {
-            "splat".fmt(f)
-        } else {
-            self.0.fmt(f)
-        }
-    }
-}
-
-impl From<u64> for LegacyInstanceKey {
-    #[inline]
-    fn from(value: u64) -> Self {
-        Self(value)
-    }
-}
-
-impl LegacyComponent for LegacyInstanceKey {
-    #[inline]
-    fn legacy_name() -> crate::ComponentName {
-        "rerun.instance_key".into()
-    }
-}
-
-impl From<re_types::components::InstanceKey> for LegacyInstanceKey {
-    #[inline]
-    fn from(other: re_types::components::InstanceKey) -> Self {
-        Self(other.0)
-    }
-}
-
-impl From<LegacyInstanceKey> for re_types::components::InstanceKey {
-    #[inline]
-    fn from(other: LegacyInstanceKey) -> Self {
-        Self(other.0)
-    }
-}
-
-use crate as re_log_types;
-
-re_log_types::component_legacy_shim!(LegacyInstanceKey);
diff --git a/crates/re_log_types/src/lib.rs b/crates/re_log_types/src/lib.rs
index c21954b9bd14..da81376ede3a 100644
--- a/crates/re_log_types/src/lib.rs
+++ b/crates/re_log_types/src/lib.rs
@@ -25,7 +25,6 @@ mod data_table;
 pub mod example_components;
 pub mod hash;
 mod index;
-mod instance_key;
 pub mod path;
 mod time;
 pub mod time_point;
@@ -51,7 +50,6 @@ pub use self::data_table::{
     METADATA_KIND_CONTROL, METADATA_KIND_DATA,
 };
 pub use self::index::*;
-pub use self::instance_key::LegacyInstanceKey;
 pub use self::path::*;
 pub use self::time::{Duration, Time};
 pub use self::time_point::{TimeInt, TimePoint, TimeType, Timeline, TimelineName};
diff --git a/crates/re_query/benches/query_benchmark.rs b/crates/re_query/benches/query_benchmark.rs
index ec7a264927aa..240a62c78b71 100644
--- a/crates/re_query/benches/query_benchmark.rs
+++ b/crates/re_query/benches/query_benchmark.rs
@@ -7,11 +7,14 @@ use itertools::Itertools;
 use re_arrow_store::{DataStore, LatestAtQuery};
 use re_components::{
     datagen::{build_frame_nr, build_some_colors, build_some_point2d, build_some_vec3d},
-    ColorRGBA, Point2D, Vec3D,
+    Vec3D,
 };
 use re_log_types::{entity_path, DataRow, EntityPath, Index, RowId, TimeType, Timeline};
 use re_query::query_entity_with_primary;
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{Color, InstanceKey, Point2D},
+    Loggable as _,
+};
 
 // ---
 
@@ -172,7 +175,7 @@ fn insert_rows<'a>(msgs: impl Iterator<Item = &'a DataRow>) -> DataStore {
 
 struct SavePoint {
     _pos: Point2D,
-    _color: Option<ColorRGBA>,
+    _color: Option<Color>,
 }
 
 fn query_and_visit_points(store: &mut DataStore, paths: &[EntityPath]) -> Vec<SavePoint> {
@@ -183,9 +186,9 @@ fn query_and_visit_points(store: &mut DataStore, paths: &[EntityPath]) -> Vec<Sa
 
     // TODO(jleibs): Add Radius once we have support for it in field_types
     for path in paths.iter() {
-        query_entity_with_primary::<Point2D>(store, &query, path, &[ColorRGBA::name()])
+        query_entity_with_primary::<Point2D>(store, &query, path, &[Color::name()])
             .and_then(|entity_view| {
-                entity_view.visit2(|_: InstanceKey, pos: Point2D, color: Option<ColorRGBA>| {
+                entity_view.visit2(|_: InstanceKey, pos: Point2D, color: Option<Color>| {
                     points.push(SavePoint {
                         _pos: pos,
                         _color: color,
diff --git a/crates/re_query/examples/range.rs b/crates/re_query/examples/range.rs
index 5b5b4cf33b87..2835ab121871 100644
--- a/crates/re_query/examples/range.rs
+++ b/crates/re_query/examples/range.rs
@@ -7,11 +7,14 @@
 use re_arrow_store::{DataStore, RangeQuery, TimeRange};
 use re_components::{
     datagen::{build_frame_nr, build_some_point2d, build_some_rects},
-    Point2D, Rect2D,
+    Rect2D,
 };
 use re_log_types::{DataRow, EntityPath, RowId, TimeType};
 use re_query::range_entity_with_primary;
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{InstanceKey, Point2D},
+    Loggable as _,
+};
 
 fn main() {
     let mut store = DataStore::new(InstanceKey::name(), Default::default());
diff --git a/crates/re_query/src/archetype_view.rs b/crates/re_query/src/archetype_view.rs
index a19f95c52cf5..fa1d49cd2d5b 100644
--- a/crates/re_query/src/archetype_view.rs
+++ b/crates/re_query/src/archetype_view.rs
@@ -43,12 +43,7 @@ impl ComponentWithInstances {
     pub fn iter_instance_keys(
         &self,
     ) -> impl Iterator<Item = re_types::components::InstanceKey> + '_ {
-        // TODO(jleibs): It's important that we still iterate over these keys
-        // via the legacy interface to avoid a performance hit from the new
-        // code-generated instance_keys.
-        self.instance_keys
-            .to_native::<re_log_types::LegacyInstanceKey>()
-            .map(|k| k.into())
+        self.instance_keys.to_native::<InstanceKey>()
     }
 
     /// Iterate over the values and convert them to a native [`Component`]
diff --git a/crates/re_query/src/dataframe_util.rs b/crates/re_query/src/dataframe_util.rs
index 2a8aabd9000e..12bd254075c8 100644
--- a/crates/re_query/src/dataframe_util.rs
+++ b/crates/re_query/src/dataframe_util.rs
@@ -213,21 +213,16 @@ impl<A: Archetype> ArchetypeView<A> {
 
 #[test]
 fn test_df_builder() {
-    use re_components::{ColorRGBA, Point2D};
+    use re_types::components::{Color, Point2D};
 
     let points = vec![
-        Some(Point2D { x: 1.0, y: 2.0 }),
-        Some(Point2D { x: 3.0, y: 4.0 }),
-        Some(Point2D { x: 5.0, y: 6.0 }),
-        Some(Point2D { x: 7.0, y: 8.0 }),
+        Some(Point2D::new(1.0, 2.0)),
+        Some(Point2D::new(3.0, 4.0)),
+        Some(Point2D::new(5.0, 6.0)),
+        Some(Point2D::new(7.0, 8.0)),
     ];
 
-    let colors = vec![
-        None,
-        Some(ColorRGBA(0xff000000)),
-        Some(ColorRGBA(0x00ff0000)),
-        None,
-    ];
+    let colors = vec![None, Some(Color(0xff000000)), Some(Color(0x00ff0000)), None];
 
     let df = df_builder2(&points, &colors).unwrap();
     // eprintln!("{df:?}");
@@ -267,7 +262,7 @@ fn test_df_builder() {
     let expected = df![
         "x" => &[1.0_f32, 3.0_f32, 5.0_f32, 7.0_f32],
         "y" => &[2.0_f32, 4.0_f32, 6.0_f32, 8.0_f32],
-        ColorRGBA::name().as_ref() => &[None, Some(0xff000000_u32), Some(0x00ff0000_u32), None ],
+        Color::name().as_ref() => &[None, Some(0xff000000_u32), Some(0x00ff0000_u32), None ],
     ]
     .unwrap();
 
diff --git a/crates/re_query/src/entity_view.rs b/crates/re_query/src/entity_view.rs
index e61fec638eec..c6eef7d28a60 100644
--- a/crates/re_query/src/entity_view.rs
+++ b/crates/re_query/src/entity_view.rs
@@ -154,17 +154,18 @@ where
 #[test]
 fn lookup_value() {
     use crate::QueryError;
-    use re_components::{Point2D, Rect2D};
+    use re_components::Rect2D;
+    use re_types::components::Point2D;
     use re_types::Loggable as _;
 
     let instance_keys = InstanceKey::from_iter(0..5);
 
     let points = [
-        Point2D { x: 1.0, y: 2.0 }, //
-        Point2D { x: 3.0, y: 4.0 },
-        Point2D { x: 5.0, y: 6.0 },
-        Point2D { x: 7.0, y: 8.0 },
-        Point2D { x: 9.0, y: 10.0 },
+        Point2D::new(1.0, 2.0), //
+        Point2D::new(3.0, 4.0),
+        Point2D::new(5.0, 6.0),
+        Point2D::new(7.0, 8.0),
+        Point2D::new(9.0, 10.0),
     ];
 
     let component =
@@ -175,7 +176,7 @@ fn lookup_value() {
 
     let value = component.lookup_arrow(&InstanceKey(2)).unwrap();
 
-    let expected_point = [points[2].clone()];
+    let expected_point = [points[2]];
     let expected_arrow = Point2D::to_arrow(expected_point, None);
 
     assert_eq!(expected_arrow, value);
@@ -188,15 +189,15 @@ fn lookup_value() {
         InstanceKey(472),
     ];
 
-    let component = ComponentWithInstances::from_native(instance_keys.as_slice(), &points);
+    let component = ComponentWithInstances::from_native(instance_keys.as_slice(), points);
 
     let missing_value = component.lookup_arrow(&InstanceKey(46));
     assert_eq!(missing_value, None);
 
     let value = component.lookup_arrow(&InstanceKey(99)).unwrap();
 
-    let expected_point = [points[3].clone()];
-    let expected_arrow = Point2D::to_arrow(&expected_point, None);
+    let expected_point = [points[3]];
+    let expected_arrow = Point2D::to_arrow(expected_point, None);
 
     assert_eq!(expected_arrow, value);
 
@@ -220,13 +221,11 @@ fn lookup_value() {
 
 #[test]
 fn lookup_splat() {
-    use re_components::Point2D;
+    use re_types::components::Point2D;
     let instances = [
         InstanceKey::SPLAT, //
     ];
-    let points = [
-        Point2D { x: 1.0, y: 2.0 }, //
-    ];
+    let points = [Point2D::new(1.0, 2.0)];
 
     let component = ComponentWithInstances::from_native(instances.as_slice(), points.as_slice());
 
diff --git a/crates/re_query/src/query.rs b/crates/re_query/src/query.rs
index 4eea123bff32..23ccb423f5d3 100644
--- a/crates/re_query/src/query.rs
+++ b/crates/re_query/src/query.rs
@@ -13,7 +13,7 @@ use crate::{ArchetypeView, ComponentWithInstances, EntityView, QueryError};
 ///
 /// ```
 /// # use re_arrow_store::LatestAtQuery;
-/// # use re_components::Point2D;
+/// # use re_types::components::Point2D;
 /// # use re_log_types::Timeline;
 /// # use re_types::Loggable as _;
 /// # let store = re_query::__populate_example_store();
@@ -86,7 +86,7 @@ pub fn get_component_with_instances(
 ///
 /// ```
 /// # use re_arrow_store::LatestAtQuery;
-/// # use re_components::{Point2D, ColorRGBA};
+/// # use re_types::components::{Point2D, Color};
 /// # use re_log_types::Timeline;
 /// # use re_types::Loggable as _;
 /// # let store = re_query::__populate_example_store();
@@ -98,7 +98,7 @@ pub fn get_component_with_instances(
 ///   &store,
 ///   &query,
 ///   &ent_path.into(),
-///   &[ColorRGBA::name()],
+///   &[Color::name()],
 /// )
 /// .unwrap();
 ///
@@ -241,7 +241,8 @@ pub fn query_archetype<A: Archetype>(
 
 /// Helper used to create an example store we can use for querying in doctests
 pub fn __populate_example_store() -> DataStore {
-    use re_components::{datagen::build_frame_nr, ColorRGBA, Point2D};
+    use re_components::datagen::build_frame_nr;
+    use re_types::components::{Color, Point2D};
 
     let mut store = DataStore::new(InstanceKey::name(), Default::default());
 
@@ -249,7 +250,7 @@ pub fn __populate_example_store() -> DataStore {
     let timepoint = [build_frame_nr(123.into())];
 
     let instances = vec![InstanceKey(42), InstanceKey(96)];
-    let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+    let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
 
     let row = DataRow::from_cells2_sized(
         RowId::random(),
@@ -261,7 +262,7 @@ pub fn __populate_example_store() -> DataStore {
     store.insert_row(&row).unwrap();
 
     let instances = vec![InstanceKey(96)];
-    let colors = vec![ColorRGBA(0xff000000)];
+    let colors = vec![Color(0xff000000)];
 
     let row = DataRow::from_cells2_sized(
         RowId::random(),
@@ -279,8 +280,8 @@ pub fn __populate_example_store() -> DataStore {
 #[test]
 fn simple_get_component() {
     use re_arrow_store::LatestAtQuery;
-    use re_components::Point2D;
     use re_log_types::Timeline;
+    use re_types::components::Point2D;
 
     let store = __populate_example_store();
 
@@ -296,10 +297,7 @@ fn simple_get_component() {
         eprintln!("{df:?}");
 
         let instances = vec![Some(InstanceKey(42)), Some(InstanceKey(96))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
 
         let expected = crate::dataframe_util::df_builder2(&instances, &points).unwrap();
 
@@ -315,33 +313,26 @@ fn simple_get_component() {
 #[test]
 fn simple_query_entity() {
     use re_arrow_store::LatestAtQuery;
-    use re_components::{ColorRGBA, Point2D};
     use re_log_types::Timeline;
+    use re_types::components::{Color, Point2D};
 
     let store = __populate_example_store();
 
     let ent_path = "point";
     let query = LatestAtQuery::new(Timeline::new_sequence("frame_nr"), 123.into());
 
-    let entity_view = query_entity_with_primary::<Point2D>(
-        &store,
-        &query,
-        &ent_path.into(),
-        &[ColorRGBA::name()],
-    )
-    .unwrap();
+    let entity_view =
+        query_entity_with_primary::<Point2D>(&store, &query, &ent_path.into(), &[Color::name()])
+            .unwrap();
 
     #[cfg(feature = "polars")]
     {
-        let df = entity_view.as_df2::<ColorRGBA>().unwrap();
+        let df = entity_view.as_df2::<Color>().unwrap();
         eprintln!("{df:?}");
 
         let instances = vec![Some(InstanceKey(42)), Some(InstanceKey(96))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
 
         let expected = crate::dataframe_util::df_builder3(&instances, &points, &colors).unwrap();
         assert_eq!(expected, df);
diff --git a/crates/re_query/src/visit.rs b/crates/re_query/src/visit.rs
index 236c933b7fdf..5310374a0413 100644
--- a/crates/re_query/src/visit.rs
+++ b/crates/re_query/src/visit.rs
@@ -7,21 +7,20 @@
 //! # Usage
 //! ```
 //! # use re_query::EntityView;
-//! # use re_components::{ColorRGBA, Point2D};
-//! # use re_types::components::InstanceKey;
+//! # use re_types::components::{Color, Point2D, InstanceKey};
 //!
 //! let instances = InstanceKey::from_iter(0..3);
 //!
 //! let points = [
-//!     Point2D { x: 1.0, y: 2.0 },
-//!     Point2D { x: 3.0, y: 4.0 },
-//!     Point2D { x: 5.0, y: 6.0 },
+//!     Point2D::new(1.0, 2.0),
+//!     Point2D::new(3.0, 4.0),
+//!     Point2D::new(5.0, 6.0),
 //! ];
 //!
 //! let colors = [
-//!     ColorRGBA(0),
-//!     ColorRGBA(1),
-//!     ColorRGBA(2),
+//!     Color(0),
+//!     Color(1),
+//!     Color(2),
 //! ];
 //!
 //! let entity_view = EntityView::from_native2(
@@ -30,10 +29,10 @@
 //! );
 //!
 //! let mut points_out = Vec::<Point2D>::new();
-//! let mut colors_out = Vec::<ColorRGBA>::new();
+//! let mut colors_out = Vec::<Color>::new();
 //!
 //! entity_view
-//!     .visit2(|_: InstanceKey, point: Point2D, color: Option<ColorRGBA>| {
+//!     .visit2(|_: InstanceKey, point: Point2D, color: Option<Color>| {
 //!         points_out.push(point);
 //!         colors_out.push(color.unwrap());
 //!     })
diff --git a/crates/re_query/tests/query_tests.rs b/crates/re_query/tests/query_tests.rs
index c5cf4179bf30..1f58aeeebbc6 100644
--- a/crates/re_query/tests/query_tests.rs
+++ b/crates/re_query/tests/query_tests.rs
@@ -1,10 +1,13 @@
 mod common;
 
 use re_arrow_store::DataStore;
-use re_components::{datagen::build_frame_nr, ColorRGBA, Point2D};
+use re_components::datagen::build_frame_nr;
 use re_log_types::{DataRow, RowId};
 use re_query::query_entity_with_primary;
-use re_types::{components::InstanceKey, Loggable};
+use re_types::{
+    components::{Color, InstanceKey, Point2D},
+    Loggable as _,
+};
 
 #[test]
 fn simple_query() {
@@ -14,13 +17,13 @@ fn simple_query() {
     let timepoint = [build_frame_nr(123.into())];
 
     // Create some points with implicit instances
-    let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+    let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
     let row = DataRow::from_cells1_sized(RowId::random(), ent_path, timepoint, 2, points);
     store.insert_row(&row).unwrap();
 
     // Assign one of them a color with an explicit instance
     let color_instances = vec![InstanceKey(1)];
-    let colors = vec![ColorRGBA(0xff000000)];
+    let colors = vec![Color(0xff000000)];
     let row = DataRow::from_cells2_sized(
         RowId::random(),
         ent_path,
@@ -37,7 +40,7 @@ fn simple_query() {
         &store,
         &timeline_query,
         &ent_path.into(),
-        &[ColorRGBA::name()],
+        &[Color::name()],
     )
     .unwrap();
 
@@ -58,17 +61,14 @@ fn simple_query() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
-        common::compare_df(&expected, &entity_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &entity_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -85,13 +85,13 @@ fn timeless_query() {
     let timepoint = [build_frame_nr(123.into())];
 
     // Create some points with implicit instances
-    let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+    let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
     let row = DataRow::from_cells1_sized(RowId::random(), ent_path, timepoint, 2, points);
     store.insert_row(&row).unwrap();
 
     // Assign one of them a color with an explicit instance.. timelessly!
     let color_instances = vec![InstanceKey(1)];
-    let colors = vec![ColorRGBA(0xff000000)];
+    let colors = vec![Color(0xff000000)];
     let row =
         DataRow::from_cells2_sized(RowId::random(), ent_path, [], 1, (color_instances, colors));
     store.insert_row(&row).unwrap();
@@ -103,7 +103,7 @@ fn timeless_query() {
         &store,
         &timeline_query,
         &ent_path.into(),
-        &[ColorRGBA::name()],
+        &[Color::name()],
     )
     .unwrap();
 
@@ -124,17 +124,14 @@ fn timeless_query() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
-        common::compare_df(&expected, &entity_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &entity_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -151,12 +148,12 @@ fn no_instance_join_query() {
     let timepoint = [build_frame_nr(123.into())];
 
     // Create some points with an implicit instance
-    let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+    let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
     let row = DataRow::from_cells1_sized(RowId::random(), ent_path, timepoint, 2, points);
     store.insert_row(&row).unwrap();
 
     // Assign them colors with explicit instances
-    let colors = vec![ColorRGBA(0xff000000), ColorRGBA(0x00ff0000)];
+    let colors = vec![Color(0xff000000), Color(0x00ff0000)];
     let row = DataRow::from_cells1_sized(RowId::random(), ent_path, timepoint, 2, colors);
     store.insert_row(&row).unwrap();
 
@@ -167,7 +164,7 @@ fn no_instance_join_query() {
         &store,
         &timeline_query,
         &ent_path.into(),
-        &[ColorRGBA::name()],
+        &[Color::name()],
     )
     .unwrap();
 
@@ -188,17 +185,14 @@ fn no_instance_join_query() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![Some(ColorRGBA(0xff000000)), Some(ColorRGBA(0x00ff0000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![Some(Color(0xff000000)), Some(Color(0x00ff0000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
-        common::compare_df(&expected, &entity_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &entity_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -215,7 +209,7 @@ fn missing_column_join_query() {
     let timepoint = [build_frame_nr(123.into())];
 
     // Create some points with an implicit instance
-    let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+    let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
     let row = DataRow::from_cells1_sized(RowId::random(), ent_path, timepoint, 2, points);
     store.insert_row(&row).unwrap();
 
@@ -226,7 +220,7 @@ fn missing_column_join_query() {
         &store,
         &timeline_query,
         &ent_path.into(),
-        &[ColorRGBA::name()],
+        &[Color::name()],
     )
     .unwrap();
 
@@ -247,10 +241,7 @@ fn missing_column_join_query() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
         let expected = df_builder2(&instances, &points).unwrap();
 
         //eprintln!("{df:?}");
@@ -273,13 +264,13 @@ fn splatted_query() {
     let timepoint = [build_frame_nr(123.into())];
 
     // Create some points with implicit instances
-    let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+    let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
     let row = DataRow::from_cells1_sized(RowId::random(), ent_path, timepoint, 2, points);
     store.insert_row(&row).unwrap();
 
     // Assign all of them a color via splat
     let color_instances = vec![InstanceKey::SPLAT];
-    let colors = vec![ColorRGBA(0xff000000)];
+    let colors = vec![Color(0xff000000)];
     let row = DataRow::from_cells2_sized(
         RowId::random(),
         ent_path,
@@ -296,7 +287,7 @@ fn splatted_query() {
         &store,
         &timeline_query,
         &ent_path.into(),
-        &[ColorRGBA::name()],
+        &[Color::name()],
     )
     .unwrap();
 
@@ -317,17 +308,14 @@ fn splatted_query() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![Some(ColorRGBA(0xff000000)), Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![Some(Color(0xff000000)), Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
-        common::compare_df(&expected, &entity_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &entity_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
diff --git a/crates/re_query/tests/range_tests.rs b/crates/re_query/tests/range_tests.rs
index 1285be7f3f58..ba8519690fc8 100644
--- a/crates/re_query/tests/range_tests.rs
+++ b/crates/re_query/tests/range_tests.rs
@@ -1,10 +1,13 @@
 mod common;
 
 use re_arrow_store::{DataStore, TimeInt, TimeRange};
-use re_components::{datagen::build_frame_nr, ColorRGBA, Point2D};
+use re_components::datagen::build_frame_nr;
 use re_log_types::{DataRow, EntityPath, RowId};
 use re_query::range_entity_with_primary;
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{Color, InstanceKey, Point2D},
+    Loggable as _,
+};
 
 #[test]
 fn simple_range() {
@@ -15,14 +18,14 @@ fn simple_range() {
     let timepoint1 = [build_frame_nr(123.into())];
     {
         // Create some points with implicit instances
-        let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+        let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
         let row =
             DataRow::from_cells1_sized(RowId::random(), ent_path.clone(), timepoint1, 2, points);
         store.insert_row(&row).unwrap();
 
         // Assign one of them a color with an explicit instance
         let color_instances = vec![InstanceKey(1)];
-        let colors = vec![ColorRGBA(0xff000000)];
+        let colors = vec![Color(0xff000000)];
         let row = DataRow::from_cells2_sized(
             RowId::random(),
             ent_path.clone(),
@@ -37,7 +40,7 @@ fn simple_range() {
     {
         // Assign one of them a color with an explicit instance
         let color_instances = vec![InstanceKey(0)];
-        let colors = vec![ColorRGBA(0xff000000)];
+        let colors = vec![Color(0xff000000)];
         let row = DataRow::from_cells2_sized(
             RowId::random(),
             ent_path.clone(),
@@ -51,7 +54,7 @@ fn simple_range() {
     let timepoint3 = [build_frame_nr(323.into())];
     {
         // Create some points with implicit instances
-        let points = vec![Point2D { x: 10.0, y: 20.0 }, Point2D { x: 30.0, y: 40.0 }];
+        let points = vec![Point2D::new(10.0, 20.0), Point2D::new(30.0, 40.0)];
         let row =
             DataRow::from_cells1_sized(RowId::random(), ent_path.clone(), timepoint3, 2, points);
         store.insert_row(&row).unwrap();
@@ -66,7 +69,7 @@ fn simple_range() {
         TimeRange::new((timepoint1[0].1.as_i64() + 1).into(), timepoint3[0].1),
     );
 
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let ent_views = range_entity_with_primary::<Point2D, 3>(&store, &query, &ent_path, components);
 
     let results = ent_views.collect::<Vec<_>>();
@@ -102,18 +105,15 @@ fn simple_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(123), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #323
 
@@ -123,17 +123,17 @@ fn simple_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![Some(ColorRGBA(0xff000000)), None];
+        let colors = vec![Some(Color(0xff000000)), None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(323), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -150,7 +150,7 @@ fn simple_range() {
         TimeRange::new(timepoint1[0].1, timepoint3[0].1),
     );
 
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let ent_views = range_entity_with_primary::<Point2D, 3>(&store, &query, &ent_path, components);
 
     let results = ent_views.collect::<Vec<_>>();
@@ -186,18 +186,15 @@ fn simple_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors: Vec<Option<ColorRGBA>> = vec![None, None];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors: Vec<Option<Color>> = vec![None, None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(123), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #323
 
@@ -207,17 +204,17 @@ fn simple_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![Some(ColorRGBA(0xff000000)), None];
+        let colors = vec![Some(Color(0xff000000)), None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(323), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -235,7 +232,7 @@ fn timeless_range() {
     let timepoint1 = [build_frame_nr(123.into())];
     {
         // Create some points with implicit instances
-        let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+        let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
         let mut row =
             DataRow::from_cells1(RowId::random(), ent_path.clone(), timepoint1, 2, &points);
         row.compute_all_size_bytes();
@@ -247,7 +244,7 @@ fn timeless_range() {
 
         // Assign one of them a color with an explicit instance
         let color_instances = vec![InstanceKey(1)];
-        let colors = vec![ColorRGBA(0xff000000)];
+        let colors = vec![Color(0xff000000)];
         let row = DataRow::from_cells2_sized(
             RowId::random(),
             ent_path.clone(),
@@ -272,7 +269,7 @@ fn timeless_range() {
     {
         // Assign one of them a color with an explicit instance
         let color_instances = vec![InstanceKey(0)];
-        let colors = vec![ColorRGBA(0xff000000)];
+        let colors = vec![Color(0xff000000)];
         let row = DataRow::from_cells2_sized(
             RowId::random(),
             ent_path.clone(),
@@ -296,7 +293,7 @@ fn timeless_range() {
     let timepoint3 = [build_frame_nr(323.into())];
     {
         // Create some points with implicit instances
-        let points = vec![Point2D { x: 10.0, y: 20.0 }, Point2D { x: 30.0, y: 40.0 }];
+        let points = vec![Point2D::new(10.0, 20.0), Point2D::new(30.0, 40.0)];
         let row =
             DataRow::from_cells1_sized(RowId::random(), ent_path.clone(), timepoint3, 2, &points);
         store.insert_row(&row).unwrap();
@@ -335,7 +332,7 @@ fn timeless_range() {
         TimeRange::new((timepoint1[0].1.as_i64() + 1).into(), timepoint3[0].1),
     );
 
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let ent_views = range_entity_with_primary::<Point2D, 3>(&store, &query, &ent_path, components);
 
     let results = ent_views.collect::<Vec<_>>();
@@ -371,18 +368,15 @@ fn timeless_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(123), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #323
 
@@ -392,17 +386,17 @@ fn timeless_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![Some(ColorRGBA(0xff000000)), None];
+        let colors = vec![Some(Color(0xff000000)), None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(323), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -419,7 +413,7 @@ fn timeless_range() {
         TimeRange::new(timepoint1[0].1, timepoint3[0].1),
     );
 
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let ent_views = range_entity_with_primary::<Point2D, 3>(&store, &query, &ent_path, components);
 
     let results = ent_views.collect::<Vec<_>>();
@@ -465,17 +459,17 @@ fn timeless_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(122), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #123 (partially timeless)
 
@@ -484,18 +478,15 @@ fn timeless_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(123), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #323
 
@@ -505,17 +496,17 @@ fn timeless_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![Some(ColorRGBA(0xff000000)), None];
+        let colors = vec![Some(Color(0xff000000)), None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(323), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -530,7 +521,7 @@ fn timeless_range() {
         TimeRange::new(TimeInt::MIN, TimeInt::MAX),
     );
 
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let ent_views = range_entity_with_primary::<Point2D, 3>(&store, &query, &ent_path, components);
 
     let results = ent_views.collect::<Vec<_>>();
@@ -583,18 +574,15 @@ fn timeless_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors: Vec<Option<ColorRGBA>> = vec![None, None];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors: Vec<Option<Color>> = vec![None, None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(&None, time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Timeless #2
 
@@ -603,17 +591,17 @@ fn timeless_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(&None, time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #123 (partially timeless)
 
@@ -622,18 +610,15 @@ fn timeless_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(123), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #323
 
@@ -643,17 +628,17 @@ fn timeless_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![Some(ColorRGBA(0xff000000)), None];
+        let colors = vec![Some(Color(0xff000000)), None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(323), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -671,14 +656,14 @@ fn simple_splatted_range() {
     let timepoint1 = [build_frame_nr(123.into())];
     {
         // Create some points with implicit instances
-        let points = vec![Point2D { x: 1.0, y: 2.0 }, Point2D { x: 3.0, y: 4.0 }];
+        let points = vec![Point2D::new(1.0, 2.0), Point2D::new(3.0, 4.0)];
         let row =
             DataRow::from_cells1_sized(RowId::random(), ent_path.clone(), timepoint1, 2, points);
         store.insert_row(&row).unwrap();
 
         // Assign one of them a color with an explicit instance
         let color_instances = vec![InstanceKey(1)];
-        let colors = vec![ColorRGBA(0xff000000)];
+        let colors = vec![Color(0xff000000)];
         let row = DataRow::from_cells2_sized(
             RowId::random(),
             ent_path.clone(),
@@ -693,7 +678,7 @@ fn simple_splatted_range() {
     {
         // Assign one of them a color with a splatted instance
         let color_instances = vec![InstanceKey::SPLAT];
-        let colors = vec![ColorRGBA(0x00ff0000)];
+        let colors = vec![Color(0x00ff0000)];
         let row = DataRow::from_cells2_sized(
             RowId::random(),
             ent_path.clone(),
@@ -707,7 +692,7 @@ fn simple_splatted_range() {
     let timepoint3 = [build_frame_nr(323.into())];
     {
         // Create some points with implicit instances
-        let points = vec![Point2D { x: 10.0, y: 20.0 }, Point2D { x: 30.0, y: 40.0 }];
+        let points = vec![Point2D::new(10.0, 20.0), Point2D::new(30.0, 40.0)];
         let row =
             DataRow::from_cells1_sized(RowId::random(), ent_path.clone(), timepoint3, 2, points);
         store.insert_row(&row).unwrap();
@@ -722,7 +707,7 @@ fn simple_splatted_range() {
         TimeRange::new((timepoint1[0].1.as_i64() + 1).into(), timepoint3[0].1),
     );
 
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let ent_views = range_entity_with_primary::<Point2D, 3>(&store, &query, &ent_path, components);
 
     let results = ent_views.collect::<Vec<_>>();
@@ -758,18 +743,15 @@ fn simple_splatted_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors = vec![None, Some(ColorRGBA(0xff000000))];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors = vec![None, Some(Color(0xff000000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(123), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #323
 
@@ -779,17 +761,17 @@ fn simple_splatted_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![Some(ColorRGBA(0x00ff0000)), Some(ColorRGBA(0x00ff0000))];
+        let colors = vec![Some(Color(0x00ff0000)), Some(Color(0x00ff0000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(323), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
@@ -806,7 +788,7 @@ fn simple_splatted_range() {
         TimeRange::new(timepoint1[0].1, timepoint3[0].1),
     );
 
-    let components = [InstanceKey::name(), Point2D::name(), ColorRGBA::name()];
+    let components = [InstanceKey::name(), Point2D::name(), Color::name()];
     let ent_views = range_entity_with_primary::<Point2D, 3>(&store, &query, &ent_path, components);
 
     let results = ent_views.collect::<Vec<_>>();
@@ -842,18 +824,15 @@ fn simple_splatted_range() {
 
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
-        let points = vec![
-            Some(Point2D { x: 1.0, y: 2.0 }),
-            Some(Point2D { x: 3.0, y: 4.0 }),
-        ];
-        let colors: Vec<Option<ColorRGBA>> = vec![None, None];
+        let points = vec![Some(Point2D::new(1.0, 2.0)), Some(Point2D::new(3.0, 4.0))];
+        let colors: Vec<Option<Color>> = vec![None, None];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(123), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
 
         // Frame #323
 
@@ -863,17 +842,17 @@ fn simple_splatted_range() {
         // Build expected df manually
         let instances = vec![Some(InstanceKey(0)), Some(InstanceKey(1))];
         let points = vec![
-            Some(Point2D { x: 10.0, y: 20.0 }),
-            Some(Point2D { x: 30.0, y: 40.0 }),
+            Some(Point2D::new(10.0, 20.0)),
+            Some(Point2D::new(30.0, 40.0)),
         ];
-        let colors = vec![Some(ColorRGBA(0x00ff0000)), Some(ColorRGBA(0x00ff0000))];
+        let colors = vec![Some(Color(0x00ff0000)), Some(Color(0x00ff0000))];
         let expected = df_builder3(&instances, &points, &colors).unwrap();
 
         //eprintln!("{df:?}");
         //eprintln!("{expected:?}");
 
         assert_eq!(TimeInt::from(323), time);
-        common::compare_df(&expected, &ent_view.as_df2::<ColorRGBA>().unwrap());
+        common::compare_df(&expected, &ent_view.as_df2::<Color>().unwrap());
     }
     #[cfg(not(feature = "polars"))]
     {
diff --git a/crates/re_query/tests/visit_tests.rs b/crates/re_query/tests/visit_tests.rs
index 6b9d251058de..05c95195287a 100644
--- a/crates/re_query/tests/visit_tests.rs
+++ b/crates/re_query/tests/visit_tests.rs
@@ -1,17 +1,16 @@
 use itertools::Itertools;
-use re_components::{ColorRGBA, Point2D};
 use re_query::{ComponentWithInstances, EntityView};
-use re_types::components::InstanceKey;
+use re_types::components::{Color, InstanceKey, Point2D};
 
 #[test]
 fn basic_single_iter() {
     let instance_keys = InstanceKey::from_iter(0..2);
     let points = [
-        Point2D { x: 1.0, y: 2.0 }, //
-        Point2D { x: 3.0, y: 4.0 },
+        Point2D::new(1.0, 2.0), //
+        Point2D::new(3.0, 4.0),
     ];
 
-    let component = ComponentWithInstances::from_native(instance_keys, &points);
+    let component = ComponentWithInstances::from_native(instance_keys, points);
 
     let results = itertools::izip!(
         points.into_iter(),
@@ -29,15 +28,15 @@ fn implicit_joined_iter() {
     let instance_keys = InstanceKey::from_iter(0..3);
 
     let points = [
-        Point2D { x: 1.0, y: 2.0 }, //
-        Point2D { x: 3.0, y: 4.0 },
-        Point2D { x: 5.0, y: 6.0 },
+        Point2D::new(1.0, 2.0), //
+        Point2D::new(3.0, 4.0),
+        Point2D::new(5.0, 6.0),
     ];
 
     let colors = [
-        ColorRGBA(0), //
-        ColorRGBA(1),
-        ColorRGBA(2),
+        Color(0), //
+        Color(1),
+        Color(2),
     ];
 
     let entity_view = EntityView::from_native2(
@@ -46,14 +45,14 @@ fn implicit_joined_iter() {
     );
 
     let expected_colors = [
-        Some(ColorRGBA(0)), //
-        Some(ColorRGBA(1)),
-        Some(ColorRGBA(2)),
+        Some(Color(0)), //
+        Some(Color(1)),
+        Some(Color(2)),
     ];
 
     let results = itertools::izip!(
         expected_colors.iter(),
-        entity_view.iter_component::<ColorRGBA>().unwrap()
+        entity_view.iter_component::<Color>().unwrap()
     )
     .collect_vec();
 
@@ -66,9 +65,9 @@ fn implicit_primary_joined_iter() {
     let point_ids = InstanceKey::from_iter(0..3);
 
     let points = [
-        Point2D { x: 1.0, y: 2.0 }, //
-        Point2D { x: 3.0, y: 4.0 },
-        Point2D { x: 5.0, y: 6.0 },
+        Point2D::new(1.0, 2.0), //
+        Point2D::new(3.0, 4.0),
+        Point2D::new(5.0, 6.0),
     ];
 
     let color_ids = [
@@ -77,8 +76,8 @@ fn implicit_primary_joined_iter() {
     ];
 
     let colors = [
-        ColorRGBA(1), //
-        ColorRGBA(2),
+        Color(1), //
+        Color(2),
     ];
 
     let entity_view = EntityView::from_native2(
@@ -88,13 +87,13 @@ fn implicit_primary_joined_iter() {
 
     let expected_colors = vec![
         None, //
-        Some(ColorRGBA(1)),
-        Some(ColorRGBA(2)),
+        Some(Color(1)),
+        Some(Color(2)),
     ];
 
     let results = itertools::izip!(
         expected_colors.iter(),
-        entity_view.iter_component::<ColorRGBA>().unwrap()
+        entity_view.iter_component::<Color>().unwrap()
     )
     .collect_vec();
 
@@ -111,19 +110,19 @@ fn implicit_component_joined_iter() {
     ];
 
     let points = [
-        Point2D { x: 1.0, y: 2.0 }, //
-        Point2D { x: 3.0, y: 4.0 },
-        Point2D { x: 5.0, y: 6.0 },
+        Point2D::new(1.0, 2.0), //
+        Point2D::new(3.0, 4.0),
+        Point2D::new(5.0, 6.0),
     ];
 
     let color_ids = InstanceKey::from_iter(0..5);
 
     let colors = [
-        ColorRGBA(0), //
-        ColorRGBA(1),
-        ColorRGBA(2),
-        ColorRGBA(3),
-        ColorRGBA(4),
+        Color(0), //
+        Color(1),
+        Color(2),
+        Color(3),
+        Color(4),
     ];
 
     let entity_view = EntityView::from_native2(
@@ -132,14 +131,14 @@ fn implicit_component_joined_iter() {
     );
 
     let expected_colors = vec![
-        Some(ColorRGBA(0)), //
-        Some(ColorRGBA(2)),
-        Some(ColorRGBA(4)),
+        Some(Color(0)), //
+        Some(Color(2)),
+        Some(Color(4)),
     ];
 
     let results = itertools::izip!(
         expected_colors.iter(),
-        entity_view.iter_component::<ColorRGBA>().unwrap()
+        entity_view.iter_component::<Color>().unwrap()
     )
     .collect_vec();
 
@@ -157,10 +156,10 @@ fn complex_joined_iter() {
     ];
 
     let points = vec![
-        Point2D { x: 1.0, y: 2.0 }, //
-        Point2D { x: 3.0, y: 4.0 },
-        Point2D { x: 5.0, y: 6.0 },
-        Point2D { x: 7.0, y: 8.0 },
+        Point2D::new(1.0, 2.0), //
+        Point2D::new(3.0, 4.0),
+        Point2D::new(5.0, 6.0),
+        Point2D::new(7.0, 8.0),
     ];
 
     let color_ids = vec![
@@ -172,11 +171,11 @@ fn complex_joined_iter() {
     ];
 
     let colors = vec![
-        ColorRGBA(17), //
-        ColorRGBA(19),
-        ColorRGBA(44),
-        ColorRGBA(96),
-        ColorRGBA(254),
+        Color(17), //
+        Color(19),
+        Color(44),
+        Color(96),
+        Color(254),
     ];
 
     let entity_view = EntityView::from_native2(
@@ -186,14 +185,14 @@ fn complex_joined_iter() {
 
     let expected_colors = vec![
         None,
-        Some(ColorRGBA(17)), //
+        Some(Color(17)), //
         None,
-        Some(ColorRGBA(96)),
+        Some(Color(96)),
     ];
 
     let results = itertools::izip!(
         expected_colors.iter(),
-        entity_view.iter_component::<ColorRGBA>().unwrap()
+        entity_view.iter_component::<Color>().unwrap()
     )
     .collect_vec();
 
@@ -205,10 +204,10 @@ fn complex_joined_iter() {
 fn single_visit() {
     let instance_keys = InstanceKey::from_iter(0..4);
     let points = [
-        Point2D { x: 1.0, y: 2.0 },
-        Point2D { x: 3.0, y: 4.0 },
-        Point2D { x: 5.0, y: 6.0 },
-        Point2D { x: 7.0, y: 8.0 },
+        Point2D::new(1.0, 2.0),
+        Point2D::new(3.0, 4.0),
+        Point2D::new(5.0, 6.0),
+        Point2D::new(7.0, 8.0),
     ];
 
     let entity_view = EntityView::from_native((&instance_keys, &points));
@@ -231,18 +230,18 @@ fn single_visit() {
 #[test]
 fn joint_visit() {
     let points = vec![
-        Point2D { x: 1.0, y: 2.0 }, //
-        Point2D { x: 3.0, y: 4.0 },
-        Point2D { x: 5.0, y: 6.0 },
-        Point2D { x: 7.0, y: 8.0 },
-        Point2D { x: 9.0, y: 10.0 },
+        Point2D::new(1.0, 2.0), //
+        Point2D::new(3.0, 4.0),
+        Point2D::new(5.0, 6.0),
+        Point2D::new(7.0, 8.0),
+        Point2D::new(9.0, 10.0),
     ];
 
     let point_ids = InstanceKey::from_iter(0..5);
 
     let colors = vec![
-        ColorRGBA(0xff000000), //
-        ColorRGBA(0x00ff0000),
+        Color(0xff000000), //
+        Color(0x00ff0000),
     ];
 
     let color_ids = vec![
@@ -256,10 +255,10 @@ fn joint_visit() {
     );
 
     let mut points_out = Vec::<Point2D>::new();
-    let mut colors_out = Vec::<Option<ColorRGBA>>::new();
+    let mut colors_out = Vec::<Option<Color>>::new();
 
     entity_view
-        .visit2(|_: InstanceKey, point: Point2D, color: Option<ColorRGBA>| {
+        .visit2(|_: InstanceKey, point: Point2D, color: Option<Color>| {
             points_out.push(point);
             colors_out.push(color);
         })
@@ -269,9 +268,9 @@ fn joint_visit() {
     let expected_colors = vec![
         None,
         None,
-        Some(ColorRGBA(0xff000000)),
+        Some(Color(0xff000000)),
         None,
-        Some(ColorRGBA(0x00ff0000)),
+        Some(Color(0x00ff0000)),
     ];
 
     assert_eq!(points, points_out);
diff --git a/crates/re_sdk/src/lib.rs b/crates/re_sdk/src/lib.rs
index 6f4d098a3496..be374c5bc4cf 100644
--- a/crates/re_sdk/src/lib.rs
+++ b/crates/re_sdk/src/lib.rs
@@ -23,7 +23,6 @@ pub use self::recording_stream::{RecordingStream, RecordingStreamBuilder};
 pub use re_sdk_comms::{default_flush_timeout, default_server_addr};
 
 pub use re_log_types::{ApplicationId, EntityPath, LegacyComponent, StoreId, StoreKind};
-pub use re_types::ComponentName;
 
 pub use global::cleanup_if_forked_child;
 
@@ -73,11 +72,14 @@ pub mod time {
 /// and can be used in [`MsgSender::with_component`].
 pub mod components {
     pub use re_components::{
-        AnnotationContext, AnnotationInfo, Arrow3D, Box3D, ClassDescription, ClassId, ColorRGBA,
-        DisconnectedSpace, DrawOrder, EncodedMesh3D, InstanceKey, KeypointId, Label, LineStrip2D,
-        LineStrip3D, Mat3x3, Mesh3D, MeshFormat, MeshId, Pinhole, Point2D, Point3D, Quaternion,
-        Radius, RawMesh3D, Rect2D, Scalar, ScalarPlotProps, Tensor, TensorData, TensorDataMeaning,
-        TensorDimension, TensorId, TextEntry, Transform3D, Vec2D, Vec3D, Vec4D, ViewCoordinates,
+        AnnotationContext, AnnotationInfo, Arrow3D, Box3D, ClassDescription, DisconnectedSpace,
+        EncodedMesh3D, LineStrip2D, LineStrip3D, Mat3x3, Mesh3D, MeshFormat, MeshId, Pinhole,
+        Quaternion, RawMesh3D, Rect2D, Scalar, ScalarPlotProps, Tensor, TensorData,
+        TensorDataMeaning, TensorDimension, TensorId, TextEntry, Transform3D, Vec2D, Vec3D, Vec4D,
+        ViewCoordinates,
+    };
+    pub use re_types::components::{
+        ClassId, Color, DrawOrder, InstanceKey, KeypointId, Label, Point2D, Point3D, Radius,
     };
 }
 
@@ -94,10 +96,9 @@ pub mod coordinates {
     pub use re_components::coordinates::{Axis3, Handedness, Sign, SignedAxis3};
 }
 
-/// Experimental APIs, to try out upcoming Rerun features.
-pub mod experimental {
-    pub use re_types::{archetypes, components, datatypes, Archetype, Component, Datatype};
-}
+pub use re_types::{
+    archetypes, datatypes, Archetype, Component, ComponentName, Datatype, Loggable,
+};
 
 /// Methods for spawning the web viewer and streaming the SDK log stream to it.
 #[cfg(feature = "web_viewer")]
diff --git a/crates/re_sdk/src/msg_sender.rs b/crates/re_sdk/src/msg_sender.rs
index 64268bf1e0e1..9b047525a97a 100644
--- a/crates/re_sdk/src/msg_sender.rs
+++ b/crates/re_sdk/src/msg_sender.rs
@@ -420,11 +420,11 @@ mod tests {
     #[test]
     fn full() -> Result<(), MsgSenderError> {
         let labels = vec![
-            components::Label("label1".into()),
-            components::Label("label2".into()),
+            re_types::components::Label("label1".into()),
+            re_types::components::Label("label2".into()),
         ];
         let transform = vec![components::Transform3D::IDENTITY];
-        let color = components::ColorRGBA::from_rgb(255, 0, 255);
+        let color = components::Color::from_rgb(255, 0, 255);
 
         let [standard, splats] = MsgSender::new("some/path")
             .with_component(&labels)?
@@ -434,7 +434,9 @@ mod tests {
 
         {
             let standard = standard.unwrap();
-            let idx = standard.find_cell(&components::Label::name()).unwrap();
+            let idx = standard
+                .find_cell(&re_types::components::Label::name())
+                .unwrap();
             let cell = &standard.cells[idx];
             assert!(cell.num_instances() == 2);
         }
@@ -446,7 +448,7 @@ mod tests {
             let cell = &splats.cells[idx];
             assert!(cell.num_instances() == 1);
 
-            let idx = splats.find_cell(&components::ColorRGBA::name()).unwrap();
+            let idx = splats.find_cell(&components::Color::name()).unwrap();
             let cell = &splats.cells[idx];
             assert!(cell.num_instances() == 1);
         }
@@ -473,7 +475,7 @@ mod tests {
 
         let sender = MsgSender::new("some/path")
             .with_timeless(true)
-            .with_component([components::Label("label1".into())].as_slice())?
+            .with_component([re_types::components::Label("label1".into())].as_slice())?
             .with_time(my_timeline, 2);
         assert!(!sender.timepoint.is_empty()); // not yet
 
@@ -486,7 +488,7 @@ mod tests {
     #[test]
     fn illegal_instance_key() -> Result<(), MsgSenderError> {
         let _ = MsgSender::new("some/path")
-            .with_component([components::Label("label1".into())].as_slice())?
+            .with_component([re_types::components::Label("label1".into())].as_slice())?
             .with_component([components::InstanceKey(u64::MAX)].as_slice())?
             .into_rows();
 
@@ -498,7 +500,7 @@ mod tests {
     #[test]
     fn splatted_instance_key() -> Result<(), MsgSenderError> {
         let res = MsgSender::new("some/path")
-            .with_component([components::Label("label1".into())].as_slice())?
+            .with_component([re_types::components::Label("label1".into())].as_slice())?
             .with_splat(components::InstanceKey(42));
 
         assert!(matches!(res, Err(MsgSenderError::SplattedInstanceKeys)));
@@ -511,8 +513,8 @@ mod tests {
         // 1 for 1 -- fine
         {
             MsgSender::new("some/path")
-                .with_component([components::Label("label1".into())].as_slice())?
-                .with_component([components::ColorRGBA::from_rgb(1, 1, 1)].as_slice())?;
+                .with_component([re_types::components::Label("label1".into())].as_slice())?
+                .with_component([components::Color::from_rgb(1, 1, 1)].as_slice())?;
         }
 
         // 3 for 1 -- fine, implicit splat
@@ -520,13 +522,13 @@ mod tests {
             MsgSender::new("some/path")
                 .with_component(
                     [
-                        components::Label("label1".into()),
-                        components::Label("label2".into()),
-                        components::Label("label3".into()),
+                        re_types::components::Label("label1".into()),
+                        re_types::components::Label("label2".into()),
+                        re_types::components::Label("label3".into()),
                     ]
                     .as_slice(),
                 )?
-                .with_component([components::ColorRGBA::from_rgb(1, 1, 1)].as_slice())?;
+                .with_component([components::Color::from_rgb(1, 1, 1)].as_slice())?;
         }
 
         // 3 for 2 -- nope, makes no sense
@@ -534,16 +536,16 @@ mod tests {
             let res = MsgSender::new("some/path")
                 .with_component(
                     [
-                        components::Label("label1".into()),
-                        components::Label("label2".into()),
-                        components::Label("label3".into()),
+                        re_types::components::Label("label1".into()),
+                        re_types::components::Label("label2".into()),
+                        re_types::components::Label("label3".into()),
                     ]
                     .as_slice(),
                 )?
                 .with_component(
                     [
-                        components::ColorRGBA::from_rgb(1, 1, 1),
-                        components::ColorRGBA::from_rgb(1, 1, 1),
+                        components::Color::from_rgb(1, 1, 1),
+                        components::Color::from_rgb(1, 1, 1),
                     ]
                     .as_slice(),
                 );
diff --git a/crates/re_space_view_spatial/src/contexts/depth_offsets.rs b/crates/re_space_view_spatial/src/contexts/depth_offsets.rs
index c241f3cb0471..e8b758311f37 100644
--- a/crates/re_space_view_spatial/src/contexts/depth_offsets.rs
+++ b/crates/re_space_view_spatial/src/contexts/depth_offsets.rs
@@ -1,9 +1,8 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use nohash_hasher::IntMap;
-use re_components::DrawOrder;
 use re_log_types::EntityPathHash;
-use re_types::Loggable as _;
+use re_types::{components::DrawOrder, Loggable as _};
 use re_viewer_context::{ArchetypeDefinition, ViewContextSystem};
 
 /// Context for creating a mapping from [`DrawOrder`] to [`re_renderer::DepthOffset`].
diff --git a/crates/re_space_view_spatial/src/mesh_loader.rs b/crates/re_space_view_spatial/src/mesh_loader.rs
index 252fbadd326e..db67354fd461 100644
--- a/crates/re_space_view_spatial/src/mesh_loader.rs
+++ b/crates/re_space_view_spatial/src/mesh_loader.rs
@@ -1,5 +1,6 @@
-use re_components::{ColorRGBA, EncodedMesh3D, Mesh3D, MeshFormat, RawMesh3D};
+use re_components::{EncodedMesh3D, Mesh3D, MeshFormat, RawMesh3D};
 use re_renderer::{resource_managers::ResourceLifeTime, RenderContext, Rgba32Unmul};
+use re_types::components::Color;
 
 pub struct LoadedMesh {
     name: String,
@@ -115,7 +116,7 @@ impl LoadedMesh {
         let vertex_colors = if let Some(vertex_colors) = vertex_colors {
             vertex_colors
                 .iter()
-                .map(|c| Rgba32Unmul::from_rgba_unmul_array(ColorRGBA(*c).to_array()))
+                .map(|c| Rgba32Unmul::from_rgba_unmul_array(Color(*c).to_array()))
                 .collect()
         } else {
             std::iter::repeat(Rgba32Unmul::WHITE)
diff --git a/crates/re_space_view_spatial/src/parts/arrows3d.rs b/crates/re_space_view_spatial/src/parts/arrows3d.rs
index c516831c8165..a021ac885800 100644
--- a/crates/re_space_view_spatial/src/parts/arrows3d.rs
+++ b/crates/re_space_view_spatial/src/parts/arrows3d.rs
@@ -1,8 +1,11 @@
-use re_components::{Arrow3D, ColorRGBA, Label, Radius};
+use re_components::Arrow3D;
 use re_data_store::EntityPath;
 use re_query::{EntityView, QueryError};
 use re_renderer::{renderer::LineStripFlags, Size};
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{Color, InstanceKey, Label, Radius},
+    Loggable as _,
+};
 use re_viewer_context::{
     ArchetypeDefinition, DefaultColor, SpaceViewSystemExecutionError, ViewContextCollection,
     ViewPartSystem, ViewQuery, ViewerContext,
@@ -45,7 +48,7 @@ impl Arrows3DPart {
         ent_view.visit4(
             |instance_key: InstanceKey,
              arrow: Arrow3D,
-             color: Option<ColorRGBA>,
+             color: Option<Color>,
              radius: Option<Radius>,
              _label: Option<Label>| {
                 // TODO(andreas): support labels
@@ -99,7 +102,7 @@ impl ViewPartSystem for Arrows3DPart {
         vec1::vec1![
             Arrow3D::name(),
             InstanceKey::name(),
-            ColorRGBA::name(),
+            Color::name(),
             Radius::name(),
             Label::name(),
         ]
diff --git a/crates/re_space_view_spatial/src/parts/boxes2d.rs b/crates/re_space_view_spatial/src/parts/boxes2d.rs
index fafe9bcaf72b..45c90952d701 100644
--- a/crates/re_space_view_spatial/src/parts/boxes2d.rs
+++ b/crates/re_space_view_spatial/src/parts/boxes2d.rs
@@ -1,8 +1,11 @@
-use re_components::{ClassId, ColorRGBA, InstanceKey, Label, Radius, Rect2D};
+use re_components::Rect2D;
 use re_data_store::EntityPath;
 use re_query::{EntityView, QueryError};
 use re_renderer::Size;
-use re_types::Loggable as _;
+use re_types::{
+    components::{ClassId, Color, InstanceKey, Label, Radius},
+    Loggable as _,
+};
 use re_viewer_context::{
     ArchetypeDefinition, DefaultColor, SpaceViewSystemExecutionError, ViewContextCollection,
     ViewPartSystem, ViewQuery, ViewerContext,
@@ -45,7 +48,7 @@ impl Boxes2DPart {
         ent_view.visit5(
             |instance_key,
              rect,
-             color: Option<ColorRGBA>,
+             color: Option<Color>,
              radius: Option<Radius>,
              label: Option<Label>,
              class_id: Option<ClassId>| {
@@ -110,7 +113,7 @@ impl ViewPartSystem for Boxes2DPart {
         vec1::vec1![
             Rect2D::name(),
             InstanceKey::name(),
-            ColorRGBA::name(),
+            Color::name(),
             Radius::name(),
             Label::name(),
             ClassId::name(),
diff --git a/crates/re_space_view_spatial/src/parts/boxes3d.rs b/crates/re_space_view_spatial/src/parts/boxes3d.rs
index 0a9967388560..e4816e4c21e2 100644
--- a/crates/re_space_view_spatial/src/parts/boxes3d.rs
+++ b/crates/re_space_view_spatial/src/parts/boxes3d.rs
@@ -1,8 +1,11 @@
-use re_components::{Box3D, ClassId, ColorRGBA, Label, Quaternion, Radius, Vec3D};
+use re_components::{Box3D, Quaternion, Vec3D};
 use re_data_store::EntityPath;
 use re_query::{EntityView, QueryError};
 use re_renderer::Size;
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{ClassId, Color, InstanceKey, Label, Radius},
+    Loggable as _,
+};
 use re_viewer_context::{
     ArchetypeDefinition, DefaultColor, SpaceViewSystemExecutionError, ViewContextCollection,
     ViewPartSystem, ViewQuery, ViewerContext,
@@ -45,7 +48,7 @@ impl Boxes3DPart {
                        half_size: Box3D,
                        position: Option<Vec3D>,
                        rotation: Option<Quaternion>,
-                       color: Option<ColorRGBA>,
+                       color: Option<Color>,
                        radius: Option<Radius>,
                        label: Option<Label>,
                        class_id: Option<ClassId>| {
@@ -107,7 +110,7 @@ impl ViewPartSystem for Boxes3DPart {
             InstanceKey::name(),
             Vec3D::name(),      // obb.position
             Quaternion::name(), // obb.rotation
-            ColorRGBA::name(),
+            Color::name(),
             Radius::name(), // stroke_width
             Label::name(),
             ClassId::name(),
diff --git a/crates/re_space_view_spatial/src/parts/images.rs b/crates/re_space_view_spatial/src/parts/images.rs
index 46233fc5bf0d..8a6bfd5d1774 100644
--- a/crates/re_space_view_spatial/src/parts/images.rs
+++ b/crates/re_space_view_spatial/src/parts/images.rs
@@ -5,9 +5,7 @@ use egui::NumExt;
 use itertools::Itertools as _;
 use nohash_hasher::IntSet;
 use re_arrow_store::LatestAtQuery;
-use re_components::{
-    ColorRGBA, DecodedTensor, DrawOrder, InstanceKey, Pinhole, Tensor, TensorDataMeaning,
-};
+use re_components::{DecodedTensor, Pinhole, Tensor, TensorDataMeaning};
 use re_data_store::{EntityPath, EntityProperties};
 use re_log_types::{ComponentName, EntityPathHash, TimeInt, Timeline};
 use re_query::{EntityView, QueryError};
@@ -15,7 +13,10 @@ use re_renderer::{
     renderer::{DepthCloud, DepthClouds, RectangleOptions, TexturedRect},
     Colormap,
 };
-use re_types::Loggable as _;
+use re_types::{
+    components::{Color, DrawOrder, InstanceKey},
+    Loggable as _,
+};
 use re_viewer_context::ViewContextCollection;
 use re_viewer_context::{
     gpu_bridge, ArchetypeDefinition, DefaultColor, SpaceViewSystemExecutionError,
@@ -204,7 +205,7 @@ impl ImagesPart {
         // Instance ids of tensors refer to entries inside the tensor.
         for (tensor, color, draw_order) in itertools::izip!(
             ent_view.iter_primary()?,
-            ent_view.iter_component::<ColorRGBA>()?,
+            ent_view.iter_component::<Color>()?,
             ent_view.iter_component::<DrawOrder>()?
         ) {
             re_tracing::profile_scope!("loop_iter");
@@ -384,7 +385,7 @@ impl ViewPartSystem for ImagesPart {
         vec1::vec1![
             Tensor::name(),
             InstanceKey::name(),
-            ColorRGBA::name(),
+            Color::name(),
             DrawOrder::name(),
         ]
     }
diff --git a/crates/re_space_view_spatial/src/parts/lines2d.rs b/crates/re_space_view_spatial/src/parts/lines2d.rs
index 724aff4cbb6c..16f359ad57b0 100644
--- a/crates/re_space_view_spatial/src/parts/lines2d.rs
+++ b/crates/re_space_view_spatial/src/parts/lines2d.rs
@@ -1,8 +1,11 @@
-use re_components::{ColorRGBA, LineStrip2D, Radius};
+use re_components::LineStrip2D;
 use re_data_store::EntityPath;
 use re_query::{EntityView, QueryError};
 use re_renderer::Size;
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{Color, InstanceKey, Radius},
+    Loggable as _,
+};
 use re_viewer_context::{
     ArchetypeDefinition, DefaultColor, SpaceViewSystemExecutionError, ViewContextCollection,
     ViewPartSystem, ViewQuery, ViewerContext,
@@ -44,7 +47,7 @@ impl Lines2DPart {
 
         let visitor = |instance_key: InstanceKey,
                        strip: LineStrip2D,
-                       color: Option<ColorRGBA>,
+                       color: Option<Color>,
                        radius: Option<Radius>| {
             // TODO(andreas): support class ids for lines
             let annotation_info = ent_context
@@ -87,7 +90,7 @@ impl ViewPartSystem for Lines2DPart {
         vec1::vec1![
             LineStrip2D::name(),
             InstanceKey::name(),
-            ColorRGBA::name(),
+            Color::name(),
             Radius::name(),
         ]
     }
diff --git a/crates/re_space_view_spatial/src/parts/lines3d.rs b/crates/re_space_view_spatial/src/parts/lines3d.rs
index ca4953d6c4d9..dd37e81282f7 100644
--- a/crates/re_space_view_spatial/src/parts/lines3d.rs
+++ b/crates/re_space_view_spatial/src/parts/lines3d.rs
@@ -1,8 +1,11 @@
-use re_components::{ColorRGBA, LineStrip3D, Radius};
+use re_components::LineStrip3D;
 use re_data_store::EntityPath;
 use re_query::{EntityView, QueryError};
 use re_renderer::Size;
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{Color, InstanceKey, Radius},
+    Loggable as _,
+};
 use re_viewer_context::{
     ArchetypeDefinition, DefaultColor, SpaceViewSystemExecutionError, ViewContextCollection,
     ViewPartSystem, ViewQuery, ViewerContext,
@@ -42,7 +45,7 @@ impl Lines3DPart {
 
         let visitor = |instance_key: InstanceKey,
                        strip: LineStrip3D,
-                       color: Option<ColorRGBA>,
+                       color: Option<Color>,
                        radius: Option<Radius>| {
             // TODO(andreas): support class ids for lines
             let annotation_info = ent_context
@@ -85,7 +88,7 @@ impl ViewPartSystem for Lines3DPart {
         vec1::vec1![
             LineStrip3D::name(),
             InstanceKey::name(),
-            ColorRGBA::name(),
+            Color::name(),
             Radius::name(),
         ]
     }
diff --git a/crates/re_space_view_spatial/src/parts/meshes.rs b/crates/re_space_view_spatial/src/parts/meshes.rs
index 917ddbba05e5..2068ef4ea0d4 100644
--- a/crates/re_space_view_spatial/src/parts/meshes.rs
+++ b/crates/re_space_view_spatial/src/parts/meshes.rs
@@ -1,8 +1,11 @@
-use re_components::{ColorRGBA, Mesh3D};
+use re_components::Mesh3D;
 use re_data_store::EntityPath;
 use re_query::{EntityView, QueryError};
 use re_renderer::renderer::MeshInstance;
-use re_types::{components::InstanceKey, Loggable as _};
+use re_types::{
+    components::{Color, InstanceKey},
+    Loggable as _,
+};
 use re_viewer_context::{
     ArchetypeDefinition, DefaultColor, SpaceViewSystemExecutionError, ViewContextCollection,
     ViewPartSystem, ViewQuery, ViewerContext,
@@ -36,7 +39,7 @@ impl MeshPart {
 
         let visitor = |instance_key: InstanceKey,
                        mesh: re_components::Mesh3D,
-                       _color: Option<ColorRGBA>| {
+                       _color: Option<Color>| {
             let picking_instance_hash =
                 re_data_store::InstancePathHash::instance(ent_path, instance_key);
 
@@ -71,7 +74,7 @@ impl MeshPart {
 
 impl ViewPartSystem for MeshPart {
     fn archetype(&self) -> ArchetypeDefinition {
-        vec1::vec1![Mesh3D::name(), InstanceKey::name(), ColorRGBA::name()]
+        vec1::vec1![Mesh3D::name(), InstanceKey::name(), Color::name()]
     }
 
     fn execute(
diff --git a/crates/re_space_view_spatial/src/parts/mod.rs b/crates/re_space_view_spatial/src/parts/mod.rs
index a617876ba9dc..a8dee8ad9ee3 100644
--- a/crates/re_space_view_spatial/src/parts/mod.rs
+++ b/crates/re_space_view_spatial/src/parts/mod.rs
@@ -26,8 +26,8 @@ pub use transform3d_arrows::add_axis_arrows;
 use ahash::HashMap;
 use std::sync::Arc;
 
-use re_components::{ClassId, ColorRGBA, KeypointId, Radius};
 use re_data_store::{EntityPath, InstancePathHash};
+use re_types::components::{ClassId, KeypointId};
 use re_viewer_context::SpaceViewClassRegistryError;
 use re_viewer_context::{
     auto_color, Annotations, DefaultColor, ResolvedAnnotationInfo, SpaceViewSystemRegistry,
@@ -101,28 +101,6 @@ pub fn picking_id_from_instance_key(
     re_renderer::PickingLayerInstanceId(instance_key.0)
 }
 
-/// Process [`ColorRGBA`] components using annotations and default colors.
-pub fn process_colors<'a, Primary>(
-    entity_view: &'a re_query::EntityView<Primary>,
-    ent_path: &'a EntityPath,
-    annotation_infos: &'a [ResolvedAnnotationInfo],
-) -> Result<impl Iterator<Item = egui::Color32> + 'a, re_query::QueryError>
-where
-    Primary: re_types::Component,
-    &'a Primary: std::convert::Into<std::borrow::Cow<'a, Primary>>,
-{
-    re_tracing::profile_function!();
-    let default_color = DefaultColor::EntityPath(ent_path);
-
-    Ok(itertools::izip!(
-        annotation_infos.iter(),
-        entity_view.iter_component::<ColorRGBA>()?,
-    )
-    .map(move |(annotation_info, color)| {
-        annotation_info.color(color.map(move |c| c.to_array()).as_ref(), default_color)
-    }))
-}
-
 /// Process [`Color`] components using annotations and default colors.
 #[allow(dead_code)]
 pub fn process_colors_arch<'a, A: Archetype>(
@@ -142,37 +120,8 @@ pub fn process_colors_arch<'a, A: Archetype>(
     }))
 }
 
-/// Process [`Radius`] components to [`re_renderer::Size`] using auto size where no radius is specified.
-pub fn process_radii<'a, Primary>(
-    ent_path: &EntityPath,
-    entity_view: &'a re_query::EntityView<Primary>,
-) -> Result<impl Iterator<Item = re_renderer::Size> + 'a, re_query::QueryError>
-where
-    Primary: re_types::Component,
-    &'a Primary: std::convert::Into<std::borrow::Cow<'a, Primary>>,
-{
-    re_tracing::profile_function!();
-    let ent_path = ent_path.clone();
-    Ok(entity_view.iter_component::<Radius>()?.map(move |radius| {
-        radius.map_or(re_renderer::Size::AUTO, |r| {
-            if 0.0 <= r.0 && r.0.is_finite() {
-                re_renderer::Size::new_scene(r.0)
-            } else {
-                if r.0 < 0.0 {
-                    re_log::warn_once!("Found negative radius in entity {ent_path}");
-                } else if r.0.is_infinite() {
-                    re_log::warn_once!("Found infinite radius in entity {ent_path}");
-                } else {
-                    re_log::warn_once!("Found NaN radius in entity {ent_path}");
-                }
-                re_renderer::Size::AUTO
-            }
-        })
-    }))
-}
-
-/// Process [`Radius`] components to [`re_renderer::Size`] using auto size where no radius is specified.
-#[allow(dead_code)]
+/// Process [`re_types::components::Radius`] components to [`re_renderer::Size`] using auto size
+/// where no radius is specified.
 pub fn process_radii_arch<'a, A: Archetype>(
     arch_view: &'a re_query::ArchetypeView<A>,
     ent_path: &EntityPath,
@@ -200,56 +149,6 @@ pub fn process_radii_arch<'a, A: Archetype>(
 }
 
 /// Resolves all annotations and keypoints for the given entity view.
-fn process_annotations_and_keypoints<'a, Primary>(
-    query: &ViewQuery<'_>,
-    entity_view: &re_query::EntityView<Primary>,
-    annotations: &Arc<Annotations>,
-) -> Result<(Vec<ResolvedAnnotationInfo>, Keypoints), re_query::QueryError>
-where
-    Primary: re_types::Component + 'a,
-    &'a Primary: std::convert::Into<std::borrow::Cow<'a, Primary>>,
-    glam::Vec3: std::convert::From<Primary>,
-{
-    re_tracing::profile_function!();
-
-    let mut keypoints: Keypoints = HashMap::default();
-
-    // No need to process annotations if we don't have keypoints or class-ids
-    if !entity_view.has_component::<KeypointId>() && !entity_view.has_component::<ClassId>() {
-        let resolved_annotation = annotations.class_description(None).annotation_info();
-        return Ok((
-            vec![resolved_annotation; entity_view.num_instances()],
-            keypoints,
-        ));
-    }
-
-    let annotation_info = itertools::izip!(
-        entity_view.iter_primary()?,
-        entity_view.iter_component::<KeypointId>()?,
-        entity_view.iter_component::<ClassId>()?,
-    )
-    .map(|(position, keypoint_id, class_id)| {
-        let class_description = annotations.class_description(class_id);
-
-        if let (Some(keypoint_id), Some(class_id), Some(position)) =
-            (keypoint_id, class_id, position)
-        {
-            keypoints
-                .entry((class_id, query.latest_at.as_i64()))
-                .or_insert_with(Default::default)
-                .insert(keypoint_id, position.into());
-            class_description.annotation_info_with_keypoint(keypoint_id)
-        } else {
-            class_description.annotation_info()
-        }
-    })
-    .collect();
-
-    Ok((annotation_info, keypoints))
-}
-
-/// Resolves all annotations and keypoints for the given entity view.
-#[allow(dead_code)]
 fn process_annotations_and_keypoints_arch<Primary, A: Archetype>(
     query: &ViewQuery<'_>,
     arch_view: &re_query::ArchetypeView<A>,
@@ -280,14 +179,14 @@ where
         arch_view.iter_optional_component::<re_types::components::ClassId>()?,
     )
     .map(|(position, keypoint_id, class_id)| {
-        let class_description = annotations.class_description(class_id.map(|c| c.into()));
+        let class_description = annotations.class_description(class_id);
 
         if let (Some(keypoint_id), Some(class_id), position) = (keypoint_id, class_id, position) {
             keypoints
-                .entry((class_id.into(), query.latest_at.as_i64()))
+                .entry((class_id, query.latest_at.as_i64()))
                 .or_insert_with(Default::default)
-                .insert(keypoint_id.into(), position.into());
-            class_description.annotation_info_with_keypoint(keypoint_id.into())
+                .insert(keypoint_id, position.into());
+            class_description.annotation_info_with_keypoint(keypoint_id)
         } else {
             class_description.annotation_info()
         }
diff --git a/crates/re_space_view_spatial/src/parts/points2d.rs b/crates/re_space_view_spatial/src/parts/points2d.rs
index 54e7037feb52..c6d6300f07a3 100644
--- a/crates/re_space_view_spatial/src/parts/points2d.rs
+++ b/crates/re_space_view_spatial/src/parts/points2d.rs
@@ -1,7 +1,10 @@
-use re_components::{ClassId, ColorRGBA, InstanceKey, KeypointId, Label, Point2D, Radius};
 use re_data_store::{EntityPath, InstancePathHash};
-use re_query::{EntityView, QueryError};
-use re_types::Loggable;
+use re_query::{ArchetypeView, QueryError};
+use re_types::{
+    archetypes::Points2D,
+    components::{Label, Point2D},
+    Archetype,
+};
 use re_viewer_context::{
     ArchetypeDefinition, ResolvedAnnotationInfo, SpaceViewSystemExecutionError,
     ViewContextCollection, ViewPartSystem, ViewQuery, ViewerContext,
@@ -10,8 +13,9 @@ use re_viewer_context::{
 use crate::{
     contexts::{EntityDepthOffsets, SpatialSceneEntityContext},
     parts::{
-        entity_iterator::process_entity_views, load_keypoint_connections,
-        process_annotations_and_keypoints, process_colors, process_radii, UiLabel, UiLabelTarget,
+        entity_iterator::process_archetype_views, load_keypoint_connections,
+        process_annotations_and_keypoints_arch, process_colors_arch, process_radii_arch, UiLabel,
+        UiLabelTarget,
     },
     view_kind::SpatialSpaceViewKind,
 };
@@ -35,15 +39,15 @@ impl Default for Points2DPart {
 
 impl Points2DPart {
     fn process_labels<'a>(
-        entity_view: &'a EntityView<Point2D>,
+        arch_view: &'a ArchetypeView<Points2D>,
         instance_path_hashes: &'a [InstancePathHash],
         colors: &'a [egui::Color32],
         annotation_infos: &'a [ResolvedAnnotationInfo],
     ) -> Result<impl Iterator<Item = UiLabel> + 'a, QueryError> {
         let labels = itertools::izip!(
             annotation_infos.iter(),
-            entity_view.iter_primary()?,
-            entity_view.iter_component::<Label>()?,
+            arch_view.iter_required_component::<Point2D>()?,
+            arch_view.iter_optional_component::<Label>()?,
             colors,
             instance_path_hashes,
         )
@@ -51,10 +55,10 @@ impl Points2DPart {
             move |(annotation_info, point, label, color, labeled_instance)| {
                 let label = annotation_info.label(label.map(|l| l.0).as_ref());
                 match (point, label) {
-                    (Some(point), Some(label)) => Some(UiLabel {
+                    (point, Some(label)) => Some(UiLabel {
                         text: label,
                         color: *color,
-                        target: UiLabelTarget::Point2D(egui::pos2(point.x, point.y)),
+                        target: UiLabelTarget::Point2D(egui::pos2(point.x(), point.y())),
                         labeled_instance: *labeled_instance,
                     }),
                     _ => None,
@@ -64,39 +68,38 @@ impl Points2DPart {
         Ok(labels)
     }
 
-    fn process_entity_view(
+    fn process_arch_view(
         &mut self,
         query: &ViewQuery<'_>,
-        entity_view: &EntityView<Point2D>,
+        arch_view: &ArchetypeView<Points2D>,
         ent_path: &EntityPath,
         ent_context: &SpatialSceneEntityContext<'_>,
     ) -> Result<(), QueryError> {
         re_tracing::profile_function!();
 
-        let (annotation_infos, keypoints) = process_annotations_and_keypoints::<Point2D>(
-            query,
-            entity_view,
-            &ent_context.annotations,
-        )?;
+        let (annotation_infos, keypoints) = process_annotations_and_keypoints_arch::<
+            Point2D,
+            Points2D,
+        >(query, arch_view, &ent_context.annotations)?;
 
-        let colors = process_colors(entity_view, ent_path, &annotation_infos)?;
-        let radii = process_radii(ent_path, entity_view)?;
+        let colors = process_colors_arch(arch_view, ent_path, &annotation_infos)?;
+        let radii = process_radii_arch(arch_view, ent_path)?;
 
-        if entity_view.num_instances() <= self.max_labels {
+        if arch_view.num_instances() <= self.max_labels {
             // Max labels is small enough that we can afford iterating on the colors again.
             let colors =
-                process_colors(entity_view, ent_path, &annotation_infos)?.collect::<Vec<_>>();
+                process_colors_arch(arch_view, ent_path, &annotation_infos)?.collect::<Vec<_>>();
 
             let instance_path_hashes_for_picking = {
                 re_tracing::profile_scope!("instance_hashes");
-                entity_view
+                arch_view
                     .iter_instance_keys()
                     .map(|instance_key| InstancePathHash::instance(ent_path, instance_key))
                     .collect::<Vec<_>>()
             };
 
             self.data.ui_labels.extend(Self::process_labels(
-                entity_view,
+                arch_view,
                 &instance_path_hashes_for_picking,
                 &colors,
                 &annotation_infos,
@@ -118,17 +121,17 @@ impl Points2DPart {
 
             let point_positions = {
                 re_tracing::profile_scope!("collect_points");
-                entity_view
-                    .iter_primary()?
-                    .filter_map(|pt| pt.map(glam::Vec2::from))
+                arch_view
+                    .iter_required_component::<Point2D>()?
+                    .map(|pt| pt.into())
             };
 
-            let picking_instance_ids = entity_view
+            let picking_instance_ids = arch_view
                 .iter_instance_keys()
                 .map(picking_id_from_instance_key);
 
             let mut point_range_builder = point_batch.add_points_2d(
-                entity_view.num_instances(),
+                arch_view.num_instances(),
                 point_positions,
                 radii,
                 colors,
@@ -140,7 +143,7 @@ impl Points2DPart {
                 re_tracing::profile_scope!("marking additional highlight points");
                 for (highlighted_key, instance_mask_ids) in &ent_context.highlight.instances {
                     // TODO(andreas/jeremy): We can do this much more efficiently
-                    let highlighted_point_index = entity_view
+                    let highlighted_point_index = arch_view
                         .iter_instance_keys()
                         .position(|key| *highlighted_key == key);
                     if let Some(highlighted_point_index) = highlighted_point_index {
@@ -157,9 +160,9 @@ impl Points2DPart {
         load_keypoint_connections(ent_context, ent_path, keypoints);
 
         self.data.extend_bounding_box_with_points(
-            entity_view
-                .iter_primary()?
-                .filter_map(|pt| pt.map(|pt| pt.into())),
+            arch_view
+                .iter_required_component::<Point2D>()?
+                .map(|pt| pt.into()),
             ent_context.world_from_obj,
         );
 
@@ -169,15 +172,7 @@ impl Points2DPart {
 
 impl ViewPartSystem for Points2DPart {
     fn archetype(&self) -> ArchetypeDefinition {
-        vec1::vec1![
-            Point2D::name(),
-            InstanceKey::name(),
-            ColorRGBA::name(),
-            Radius::name(),
-            Label::name(),
-            ClassId::name(),
-            KeypointId::name()
-        ]
+        Points2D::all_components().try_into().unwrap()
     }
 
     fn execute(
@@ -188,14 +183,13 @@ impl ViewPartSystem for Points2DPart {
     ) -> Result<Vec<re_renderer::QueueableDrawData>, SpaceViewSystemExecutionError> {
         re_tracing::profile_scope!("Points2DPart");
 
-        process_entity_views::<re_components::Point2D, 7, _>(
+        process_archetype_views::<Points2D, { Points2D::NUM_COMPONENTS }, _>(
             ctx,
             query,
             view_ctx,
             view_ctx.get::<EntityDepthOffsets>()?.points,
-            self.archetype(),
-            |_ctx, ent_path, entity_view, ent_context| {
-                self.process_entity_view(query, &entity_view, ent_path, ent_context)
+            |_ctx, ent_path, arch_view, ent_context| {
+                self.process_arch_view(query, &arch_view, ent_path, ent_context)
             },
         )?;
 
diff --git a/crates/re_space_view_spatial/src/parts/points3d.rs b/crates/re_space_view_spatial/src/parts/points3d.rs
index c63278e3ccaf..1ba3cbb73644 100644
--- a/crates/re_space_view_spatial/src/parts/points3d.rs
+++ b/crates/re_space_view_spatial/src/parts/points3d.rs
@@ -1,24 +1,26 @@
-use re_components::{ClassId, ColorRGBA, InstanceKey, KeypointId, Label, Point3D, Radius};
 use re_data_store::{EntityPath, InstancePathHash};
-use re_query::{EntityView, QueryError};
-use re_types::Loggable as _;
+use re_query::{ArchetypeView, QueryError};
+use re_types::{
+    archetypes::Points3D,
+    components::{Label, Point3D},
+    Archetype as _,
+};
 use re_viewer_context::{
     ArchetypeDefinition, ResolvedAnnotationInfo, SpaceViewSystemExecutionError,
     ViewContextCollection, ViewPartSystem, ViewQuery, ViewerContext,
 };
 
 use crate::{
-    contexts::SpatialSceneEntityContext,
+    contexts::{EntityDepthOffsets, SpatialSceneEntityContext},
     parts::{
-        entity_iterator::process_entity_views, load_keypoint_connections, UiLabel, UiLabelTarget,
+        entity_iterator::process_archetype_views, load_keypoint_connections,
+        process_annotations_and_keypoints_arch, process_colors_arch, process_radii_arch, UiLabel,
+        UiLabelTarget,
     },
     view_kind::SpatialSpaceViewKind,
 };
 
-use super::{
-    picking_id_from_instance_key, process_annotations_and_keypoints, process_colors, process_radii,
-    SpatialViewPartData,
-};
+use super::{picking_id_from_instance_key, SpatialViewPartData};
 
 pub struct Points3DPart {
     /// If the number of points in the batch is > max_labels, don't render point labels.
@@ -37,7 +39,7 @@ impl Default for Points3DPart {
 
 impl Points3DPart {
     fn process_labels<'a>(
-        entity_view: &'a EntityView<Point3D>,
+        arch_view: &'a ArchetypeView<Points3D>,
         instance_path_hashes: &'a [InstancePathHash],
         colors: &'a [egui::Color32],
         annotation_infos: &'a [ResolvedAnnotationInfo],
@@ -45,8 +47,8 @@ impl Points3DPart {
     ) -> Result<impl Iterator<Item = UiLabel> + 'a, QueryError> {
         let labels = itertools::izip!(
             annotation_infos.iter(),
-            entity_view.iter_primary()?,
-            entity_view.iter_component::<Label>()?,
+            arch_view.iter_required_component::<Point3D>()?,
+            arch_view.iter_optional_component::<Label>()?,
             colors,
             instance_path_hashes,
         )
@@ -54,7 +56,7 @@ impl Points3DPart {
             move |(annotation_info, point, label, color, labeled_instance)| {
                 let label = annotation_info.label(label.map(|l| l.0).as_ref());
                 match (point, label) {
-                    (Some(point), Some(label)) => Some(UiLabel {
+                    (point, Some(label)) => Some(UiLabel {
                         text: label,
                         color: *color,
                         target: UiLabelTarget::Position3D(
@@ -69,35 +71,38 @@ impl Points3DPart {
         Ok(labels)
     }
 
-    fn process_entity_view(
+    fn process_arch_view(
         &mut self,
         query: &ViewQuery<'_>,
-        ent_view: &EntityView<Point3D>,
+        arch_view: &ArchetypeView<Points3D>,
         ent_path: &EntityPath,
         ent_context: &SpatialSceneEntityContext<'_>,
     ) -> Result<(), QueryError> {
         re_tracing::profile_function!();
 
-        let (annotation_infos, keypoints) =
-            process_annotations_and_keypoints(query, ent_view, &ent_context.annotations)?;
+        let (annotation_infos, keypoints) = process_annotations_and_keypoints_arch::<
+            Point3D,
+            Points3D,
+        >(query, arch_view, &ent_context.annotations)?;
 
-        let colors = process_colors(ent_view, ent_path, &annotation_infos)?;
-        let radii = process_radii(ent_path, ent_view)?;
+        let colors = process_colors_arch(arch_view, ent_path, &annotation_infos)?;
+        let radii = process_radii_arch(arch_view, ent_path)?;
 
-        if ent_view.num_instances() <= self.max_labels {
+        if arch_view.num_instances() <= self.max_labels {
             // Max labels is small enough that we can afford iterating on the colors again.
-            let colors = process_colors(ent_view, ent_path, &annotation_infos)?.collect::<Vec<_>>();
+            let colors =
+                process_colors_arch(arch_view, ent_path, &annotation_infos)?.collect::<Vec<_>>();
 
             let instance_path_hashes_for_picking = {
                 re_tracing::profile_scope!("instance_hashes");
-                ent_view
+                arch_view
                     .iter_instance_keys()
                     .map(|instance_key| InstancePathHash::instance(ent_path, instance_key))
                     .collect::<Vec<_>>()
             };
 
             self.data.ui_labels.extend(Self::process_labels(
-                ent_view,
+                arch_view,
                 &instance_path_hashes_for_picking,
                 &colors,
                 &annotation_infos,
@@ -115,16 +120,16 @@ impl Points3DPart {
 
             let point_positions = {
                 re_tracing::profile_scope!("collect_points");
-                ent_view
-                    .iter_primary()?
-                    .filter_map(|pt| pt.map(glam::Vec3::from))
+                arch_view
+                    .iter_required_component::<Point3D>()?
+                    .map(glam::Vec3::from)
             };
 
-            let picking_instance_ids = ent_view
+            let picking_instance_ids = arch_view
                 .iter_instance_keys()
                 .map(picking_id_from_instance_key);
             let mut point_range_builder = point_batch.add_points(
-                ent_view.num_instances(),
+                arch_view.num_instances(),
                 point_positions,
                 radii,
                 colors,
@@ -136,7 +141,7 @@ impl Points3DPart {
                 re_tracing::profile_scope!("marking additional highlight points");
                 for (highlighted_key, instance_mask_ids) in &ent_context.highlight.instances {
                     // TODO(andreas/jeremy): We can do this much more efficiently
-                    let highlighted_point_index = ent_view
+                    let highlighted_point_index = arch_view
                         .iter_instance_keys()
                         .position(|key| *highlighted_key == key);
                     if let Some(highlighted_point_index) = highlighted_point_index {
@@ -153,9 +158,9 @@ impl Points3DPart {
         load_keypoint_connections(ent_context, ent_path, keypoints);
 
         self.data.extend_bounding_box_with_points(
-            ent_view
-                .iter_primary()?
-                .filter_map(|pt| pt.map(|pt| pt.into())),
+            arch_view
+                .iter_required_component::<Point3D>()?
+                .map(glam::Vec3::from),
             ent_context.world_from_obj,
         );
 
@@ -165,15 +170,7 @@ impl Points3DPart {
 
 impl ViewPartSystem for Points3DPart {
     fn archetype(&self) -> ArchetypeDefinition {
-        vec1::vec1![
-            Point3D::name(),
-            InstanceKey::name(),
-            ColorRGBA::name(),
-            Radius::name(),
-            Label::name(),
-            ClassId::name(),
-            KeypointId::name(),
-        ]
+        Points3D::all_components().try_into().unwrap()
     }
 
     fn execute(
@@ -184,14 +181,13 @@ impl ViewPartSystem for Points3DPart {
     ) -> Result<Vec<re_renderer::QueueableDrawData>, SpaceViewSystemExecutionError> {
         re_tracing::profile_scope!("Points3DPart");
 
-        process_entity_views::<re_components::Point3D, 7, _>(
+        process_archetype_views::<Points3D, { Points3D::NUM_COMPONENTS }, _>(
             ctx,
             query,
             view_ctx,
-            0,
-            self.archetype(),
-            |_ctx, ent_path, entity_view, ent_context| {
-                self.process_entity_view(query, &entity_view, ent_path, ent_context)
+            view_ctx.get::<EntityDepthOffsets>()?.points,
+            |_ctx, ent_path, arch_view, ent_context| {
+                self.process_arch_view(query, &arch_view, ent_path, ent_context)
             },
         )?;
 
diff --git a/crates/re_space_view_spatial/src/parts/transform3d_arrows.rs b/crates/re_space_view_spatial/src/parts/transform3d_arrows.rs
index 2c0c95cbc29a..2b4db54cf23f 100644
--- a/crates/re_space_view_spatial/src/parts/transform3d_arrows.rs
+++ b/crates/re_space_view_spatial/src/parts/transform3d_arrows.rs
@@ -1,8 +1,8 @@
 use egui::Color32;
-use re_components::{InstanceKey, Transform3D};
+use re_components::Transform3D;
 use re_log_types::EntityPath;
 use re_renderer::LineStripSeriesBuilder;
-use re_types::Loggable as _;
+use re_types::{components::InstanceKey, Loggable as _};
 use re_viewer_context::{
     ArchetypeDefinition, SpaceViewSystemExecutionError, ViewContextCollection, ViewPartSystem,
     ViewQuery, ViewerContext,
diff --git a/crates/re_space_view_text/src/view_part_system.rs b/crates/re_space_view_text/src/view_part_system.rs
index 877788bba108..77b03e949899 100644
--- a/crates/re_space_view_text/src/view_part_system.rs
+++ b/crates/re_space_view_text/src/view_part_system.rs
@@ -53,7 +53,7 @@ impl ViewPartSystem for TextSystem {
             let components = [
                 InstanceKey::name(),
                 re_components::TextEntry::name(),
-                re_components::ColorRGBA::name(),
+                re_types::components::Color::name(),
             ];
             let ent_views = range_entity_with_primary::<re_components::TextEntry, 3>(
                 store, &query, ent_path, components,
@@ -63,7 +63,7 @@ impl ViewPartSystem for TextSystem {
                 match ent_view.visit2(
                     |_instance,
                      text_entry: re_components::TextEntry,
-                     color: Option<re_components::ColorRGBA>| {
+                     color: Option<re_types::components::Color>| {
                         let re_components::TextEntry { body, level } = text_entry;
 
                         self.text_entries.push(TextEntry {
diff --git a/crates/re_space_view_time_series/src/view_part_system.rs b/crates/re_space_view_time_series/src/view_part_system.rs
index 54e3d5e4032e..72e847ed93dd 100644
--- a/crates/re_space_view_time_series/src/view_part_system.rs
+++ b/crates/re_space_view_time_series/src/view_part_system.rs
@@ -102,9 +102,9 @@ impl TimeSeriesSystem {
             InstanceKey::name(),
             re_components::Scalar::name(),
             re_components::ScalarPlotProps::name(),
-            re_components::ColorRGBA::name(),
-            re_components::Radius::name(),
-            re_components::Label::name(),
+            re_types::components::Color::name(),
+            re_types::components::Radius::name(),
+            re_types::components::Label::name(),
         ]
     }
 
@@ -136,9 +136,9 @@ impl TimeSeriesSystem {
                     |_instance,
                      scalar: re_components::Scalar,
                      props: Option<re_components::ScalarPlotProps>,
-                     color: Option<re_components::ColorRGBA>,
-                     radius: Option<re_components::Radius>,
-                     label: Option<re_components::Label>| {
+                     color: Option<re_types::components::Color>,
+                     radius: Option<re_types::components::Radius>,
+                     label: Option<re_types::components::Label>| {
                         // TODO(andreas): Support entity path
                         let color = annotation_info
                             .color(color.map(|c| c.to_array()).as_ref(), default_color);
diff --git a/crates/re_types/Cargo.toml b/crates/re_types/Cargo.toml
index c5c96aad5f9b..ff9ab5b1a9c5 100644
--- a/crates/re_types/Cargo.toml
+++ b/crates/re_types/Cargo.toml
@@ -49,6 +49,7 @@ arrow2 = { workspace = true, features = [
   "compute_concatenate",
 ] }
 anyhow.workspace = true
+arrow2_convert.workspace = true
 backtrace = "0.3"
 bytemuck = { version = "1.11", features = ["derive", "extern_crate_alloc"] }
 document-features = "0.2"
diff --git a/crates/re_types/definitions/rerun/components/class_id.fbs b/crates/re_types/definitions/rerun/components/class_id.fbs
index cfcb5c0859c6..e38e21c0716b 100644
--- a/crates/re_types/definitions/rerun/components/class_id.fbs
+++ b/crates/re_types/definitions/rerun/components/class_id.fbs
@@ -8,6 +8,8 @@ namespace rerun.components;
 
 // ---
 
+// TODO(#2801): serde should be cfg_attr gated here
+
 /// A 16-bit ID representing a type of semantic class.
 ///
 /// \rs Used to look up a `crate::components::ClassDescription` within the `crate::components::AnnotationContext`.
@@ -15,7 +17,7 @@ struct ClassId (
   "attr.python.aliases": "int",
   "attr.python.array_aliases": "int, npt.NDArray[np.uint8], npt.NDArray[np.uint16], npt.NDArray[np.uint32], npt.NDArray[np.uint64]",
   "attr.rerun.legacy_fqname": "rerun.class_id",
-  "attr.rust.derive": "Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash",
+  "attr.rust.derive": "Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, ::serde::Serialize, ::serde::Deserialize",
   order: 100
 ) {
   id: ushort (order: 100);
diff --git a/crates/re_types/definitions/rerun/components/instance_key.fbs b/crates/re_types/definitions/rerun/components/instance_key.fbs
index 8e9e0df2d3d6..e9cace16ef5e 100644
--- a/crates/re_types/definitions/rerun/components/instance_key.fbs
+++ b/crates/re_types/definitions/rerun/components/instance_key.fbs
@@ -14,7 +14,7 @@ struct InstanceKey (
   "attr.python.aliases": "int",
   "attr.python.array_aliases": "int, npt.NDArray[np.uint64]",
   "attr.rerun.legacy_fqname": "rerun.instance_key",
-  "attr.rust.derive": "Copy, Hash, PartialEq, Eq, PartialOrd, Ord",
+  "attr.rust.derive": "Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Default",
   "attr.rust.custom_clause":
     'cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))',
   order: 100
diff --git a/crates/re_types/definitions/rerun/components/keypoint_id.fbs b/crates/re_types/definitions/rerun/components/keypoint_id.fbs
index 4682167cd70b..f13b2ba56cfb 100644
--- a/crates/re_types/definitions/rerun/components/keypoint_id.fbs
+++ b/crates/re_types/definitions/rerun/components/keypoint_id.fbs
@@ -8,6 +8,8 @@ namespace rerun.components;
 
 // ---
 
+// TODO(#2801): serde should be cfg_attr gated here
+
 /// A 16-bit ID representing a type of semantic keypoint within a class.
 ///
 /// \py `KeypointId`s are only meaningful within the context of a [`rerun.components.ClassDescription`][].
@@ -22,7 +24,7 @@ struct KeypointId (
   "attr.python.aliases": "float",
   "attr.python.array_aliases": "float, npt.NDArray[np.uint8], npt.NDArray[np.uint16], npt.NDArray[np.uint32]",
   "attr.rerun.legacy_fqname": "rerun.keypoint_id",
-  "attr.rust.derive": "Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash",
+  "attr.rust.derive": "Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, ::serde::Serialize, ::serde::Deserialize",
   order: 200
 ) {
   id: ushort (order: 100);
diff --git a/crates/re_types/source_hash.txt b/crates/re_types/source_hash.txt
index 9ac9a8ebe0d7..1e69e519b4cd 100644
--- a/crates/re_types/source_hash.txt
+++ b/crates/re_types/source_hash.txt
@@ -1,4 +1,4 @@
 # This is a sha256 hash for all direct and indirect dependencies of this crate's build script.
 # It can be safely removed at anytime to force the build script to run again.
 # Check out build.rs to see how it's computed.
-850c40e226cb550a05285b9b2371890c307e0807ea19ec5ef453f95557e375bd
+50fc3b2b2d539cc880a373b2edc187c090cb40670fbd1230f699a7cbe6961d83
diff --git a/crates/re_types/src/archetypes/points2d.rs b/crates/re_types/src/archetypes/points2d.rs
index 321c4095a493..6960a03cfef3 100644
--- a/crates/re_types/src/archetypes/points2d.rs
+++ b/crates/re_types/src/archetypes/points2d.rs
@@ -20,8 +20,8 @@
 /// //! Log some very simple points.
 ///
 /// use rerun::{
+///    archetypes::Points2D,
 ///    components::{Rect2D, Vec4D},
-///    experimental::archetypes::Points2D,
 ///    MsgSender, RecordingStreamBuilder,
 /// };
 ///
diff --git a/crates/re_types/src/archetypes/points3d.rs b/crates/re_types/src/archetypes/points3d.rs
index 5afbc582c39c..d47e83190031 100644
--- a/crates/re_types/src/archetypes/points3d.rs
+++ b/crates/re_types/src/archetypes/points3d.rs
@@ -18,7 +18,7 @@
 ///
 /// ```ignore
 /// //! Log some very simple points.
-/// use rerun::{experimental::archetypes::Points3D, MsgSender, RecordingStreamBuilder};
+/// use rerun::{archetypes::Points3D, MsgSender, RecordingStreamBuilder};
 ///
 /// fn main() -> Result<(), Box<dyn std::error::Error>> {
 ///    let (rec_stream, storage) = RecordingStreamBuilder::new("points").memory()?;
diff --git a/crates/re_types/src/archetypes/transform3d.rs b/crates/re_types/src/archetypes/transform3d.rs
index 6492343db68d..54066d7e553c 100644
--- a/crates/re_types/src/archetypes/transform3d.rs
+++ b/crates/re_types/src/archetypes/transform3d.rs
@@ -20,12 +20,9 @@
 /// //! Log some transforms.
 ///
 /// use rerun::{
-///    experimental::{
-///        archetypes::Transform3D,
-///        datatypes::{
-///            Angle, Mat3x3, RotationAxisAngle, Scale3D, TranslationAndMat3x3,
-///            TranslationRotationScale3D,
-///        },
+///    archetypes::Transform3D,
+///    datatypes::{
+///        Angle, Mat3x3, RotationAxisAngle, Scale3D, TranslationAndMat3x3, TranslationRotationScale3D,
 ///    },
 ///    MsgSender, RecordingStreamBuilder,
 /// };
diff --git a/crates/re_types/src/components/class_id.rs b/crates/re_types/src/components/class_id.rs
index 593ba18f7885..a6df4e65685f 100644
--- a/crates/re_types/src/components/class_id.rs
+++ b/crates/re_types/src/components/class_id.rs
@@ -15,7 +15,19 @@
 /// A 16-bit ID representing a type of semantic class.
 ///
 /// Used to look up a `crate::components::ClassDescription` within the `crate::components::AnnotationContext`.
-#[derive(Clone, Debug, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(
+    Clone,
+    Debug,
+    Copy,
+    Default,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    :: serde :: Serialize,
+    :: serde :: Deserialize,
+)]
 pub struct ClassId(pub u16);
 
 impl<'a> From<ClassId> for ::std::borrow::Cow<'a, ClassId> {
diff --git a/crates/re_types/src/components/instance_key.rs b/crates/re_types/src/components/instance_key.rs
index 03b2e01b79ca..0e39c80ef03e 100644
--- a/crates/re_types/src/components/instance_key.rs
+++ b/crates/re_types/src/components/instance_key.rs
@@ -13,7 +13,7 @@
 #![allow(clippy::unnecessary_cast)]
 
 /// A unique numeric identifier for each individual instance within a batch.
-#[derive(Clone, Debug, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Debug, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]
 #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
 pub struct InstanceKey(pub u64);
 
diff --git a/crates/re_types/src/components/keypoint_id.rs b/crates/re_types/src/components/keypoint_id.rs
index daaf25143d2c..9ade2f63e2e8 100644
--- a/crates/re_types/src/components/keypoint_id.rs
+++ b/crates/re_types/src/components/keypoint_id.rs
@@ -17,7 +17,19 @@
 /// `KeypointId`s are only meaningful within the context of a `crate::components::ClassDescription`.
 ///
 /// Used to look up an `crate::components::AnnotationInfo` for a Keypoint within the `crate::components::AnnotationContext`.
-#[derive(Clone, Debug, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(
+    Clone,
+    Debug,
+    Copy,
+    Default,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    :: serde :: Serialize,
+    :: serde :: Deserialize,
+)]
 pub struct KeypointId(pub u16);
 
 impl<'a> From<KeypointId> for ::std::borrow::Cow<'a, KeypointId> {
diff --git a/crates/re_types/src/components/point2d_ext.rs b/crates/re_types/src/components/point2d_ext.rs
index 165b54711432..3b8dc3913ce4 100644
--- a/crates/re_types/src/components/point2d_ext.rs
+++ b/crates/re_types/src/components/point2d_ext.rs
@@ -59,3 +59,17 @@ impl From<Point2D> for glam::Vec3 {
         Self::new(pt.x(), pt.y(), 0.0)
     }
 }
+
+// NOTE: We have a ton of legacy tests that rely on the old APIs and `Point2D`.
+// Since the new `Point2D` is binary compatible with the old we can easily drop the old one, but
+// for that we need the new one to implement the `LegacyComponent` trait, which means implementing
+// `ArrowField` to begin with!
+// TODO(cmc): remove once the migration is over
+impl arrow2_convert::field::ArrowField for Point2D {
+    type Type = Self;
+
+    fn data_type() -> arrow2::datatypes::DataType {
+        use crate::Loggable as _;
+        Self::to_arrow_datatype()
+    }
+}
diff --git a/crates/re_viewer_context/src/annotations.rs b/crates/re_viewer_context/src/annotations.rs
index 9d153b68e115..380a55760c31 100644
--- a/crates/re_viewer_context/src/annotations.rs
+++ b/crates/re_viewer_context/src/annotations.rs
@@ -6,11 +6,12 @@ use nohash_hasher::IntSet;
 use re_arrow_store::LatestAtQuery;
 use re_components::{
     context::{AnnotationInfo, ClassDescription},
-    AnnotationContext, ClassId, KeypointId,
+    AnnotationContext,
 };
 use re_data_store::EntityPath;
 use re_log_types::RowId;
 use re_query::query_entity_with_primary;
+use re_types::components::{ClassId, KeypointId};
 
 use super::{auto_color, ViewerContext};
 use crate::DefaultColor;
diff --git a/crates/re_viewer_context/src/gpu_bridge/tensor_to_gpu.rs b/crates/re_viewer_context/src/gpu_bridge/tensor_to_gpu.rs
index e5007fd33896..2cc76ded481d 100644
--- a/crates/re_viewer_context/src/gpu_bridge/tensor_to_gpu.rs
+++ b/crates/re_viewer_context/src/gpu_bridge/tensor_to_gpu.rs
@@ -15,6 +15,7 @@ use re_renderer::{
     resource_managers::Texture2DCreationDesc,
     RenderContext,
 };
+use re_types::components::ClassId;
 
 use crate::{Annotations, DefaultColor, TensorStats};
 
@@ -176,7 +177,7 @@ fn class_id_tensor_to_gpu(
             let data: Vec<u8> = (0..(colormap_width * colormap_height))
                 .flat_map(|id| {
                     let color = annotations
-                        .class_description(Some(re_components::ClassId(id as u16)))
+                        .class_description(Some(ClassId(id as u16)))
                         .annotation_info()
                         .color(None, DefaultColor::TransparentBlack);
                     color.to_array() // premultiplied!
diff --git a/crates/re_viewport/src/space_view_heuristics.rs b/crates/re_viewport/src/space_view_heuristics.rs
index ac4b97145645..3d7f7f4b654e 100644
--- a/crates/re_viewport/src/space_view_heuristics.rs
+++ b/crates/re_viewport/src/space_view_heuristics.rs
@@ -223,7 +223,10 @@ pub fn default_created_space_views(
                 if let Some(tensor) = store.query_latest_component::<Tensor>(entity_path, &query) {
                     if let Some([height, width, _]) = tensor.image_height_width_channels() {
                         if store
-                            .query_latest_component::<re_components::DrawOrder>(entity_path, &query)
+                            .query_latest_component::<re_types::components::DrawOrder>(
+                                entity_path,
+                                &query,
+                            )
                             .is_some()
                         {
                             // Put everything in the same bucket if it has a draw order.
diff --git a/crates/rerun/src/lib.rs b/crates/rerun/src/lib.rs
index e02b0d672bcc..ab12d73b4083 100644
--- a/crates/rerun/src/lib.rs
+++ b/crates/rerun/src/lib.rs
@@ -33,11 +33,11 @@
 //! # use rerun::external::image;
 //! # fn capture_image() -> image::DynamicImage { Default::default() }
 //! # fn positions() -> Vec<rerun::components::Point3D> { Default::default() }
-//! # fn colors() -> Vec<rerun::components::ColorRGBA> { Default::default() }
+//! # fn colors() -> Vec<rerun::components::Color> { Default::default() }
 //! let rec_stream = rerun::RecordingStreamBuilder::new("my_app").buffered()?;
 //!
 //! let points: Vec<rerun::components::Point3D> = positions();
-//! let colors: Vec<rerun::components::ColorRGBA> = colors();
+//! let colors: Vec<rerun::components::Color> = colors();
 //! let image: image::DynamicImage = capture_image();
 //!
 //! rerun::MsgSender::new("points")
diff --git a/docs/code-examples/annotation-context/example.rs b/docs/code-examples/annotation-context/example.rs
index 111a909f3627..1fa6e0980204 100644
--- a/docs/code-examples/annotation-context/example.rs
+++ b/docs/code-examples/annotation-context/example.rs
@@ -15,7 +15,7 @@ MsgSender::new("masks") // Applies to all entities below "masks".
                 info: AnnotationInfo {
                     id: 0,
                     label: Some(Label("Person".into())),
-                    color: Some(ColorRGBA(0xFF000000)),
+                    color: Some(Color(0xFF000000)),
                 },
                 ..Default::default()
             },
@@ -42,7 +42,7 @@ MsgSender::new("detections") // Applies to all entities below "detections".
                     .map(|i| AnnotationInfo {
                         id: i,
                         label: None,
-                        color: Some(ColorRGBA::from_rgb(0, (255 / 9 * i) as u8, 0)),
+                        color: Some(Color::from_rgb(0, (255 / 9 * i) as u8, 0)),
                     })
                     .map(|keypoint| (KeypointId(keypoint.id), keypoint))
                     .collect(),
diff --git a/docs/code-examples/annotation_context_connections.rs b/docs/code-examples/annotation_context_connections.rs
index 7a15a4c9fe88..ce75b0c30f90 100644
--- a/docs/code-examples/annotation_context_connections.rs
+++ b/docs/code-examples/annotation_context_connections.rs
@@ -1,7 +1,6 @@
 //! Log some very simple points.
 use rerun::components::{
-    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, ColorRGBA, KeypointId, Label,
-    Point3D,
+    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, Color, KeypointId, Label, Point3D,
 };
 use rerun::{MsgSender, RecordingStreamBuilder};
 
@@ -17,32 +16,32 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         KeypointId(0),
         AnnotationInfo {
             id: 0,
-            label: Some(Label("zero".to_owned())),
-            color: Some(ColorRGBA::from_rgb(255, 0, 0)),
+            label: Some(Label("zero".into()).into()),
+            color: Some(Color::from_rgb(255, 0, 0).into()),
         },
     );
     class_desc.keypoint_map.insert(
         KeypointId(1),
         AnnotationInfo {
             id: 1,
-            label: Some(Label("one".to_owned())),
-            color: Some(ColorRGBA::from_rgb(0, 255, 0)),
+            label: Some(Label("one".into()).into()),
+            color: Some(Color::from_rgb(0, 255, 0).into()),
         },
     );
     class_desc.keypoint_map.insert(
         KeypointId(2),
         AnnotationInfo {
             id: 2,
-            label: Some(Label("two".to_owned())),
-            color: Some(ColorRGBA::from_rgb(0, 0, 255)),
+            label: Some(Label("two".into()).into()),
+            color: Some(Color::from_rgb(0, 0, 255).into()),
         },
     );
     class_desc.keypoint_map.insert(
         KeypointId(3),
         AnnotationInfo {
             id: 3,
-            label: Some(Label("three".to_owned())),
-            color: Some(ColorRGBA::from_rgb(255, 255, 0)),
+            label: Some(Label("three".into()).into()),
+            color: Some(Color::from_rgb(255, 255, 0).into()),
         },
     );
     class_desc.keypoint_connections = [(0, 2), (1, 2), (2, 3)]
diff --git a/docs/code-examples/annotation_context_rects.rs b/docs/code-examples/annotation_context_rects.rs
index 2cb926e31429..a6af4cd34951 100644
--- a/docs/code-examples/annotation_context_rects.rs
+++ b/docs/code-examples/annotation_context_rects.rs
@@ -1,6 +1,6 @@
 //! Log rectangles with different colors and labels.
 use rerun::components::{
-    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, ColorRGBA, Label, Rect2D, Vec4D,
+    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, Color, Label, Rect2D, Vec4D,
 };
 use rerun::{MsgSender, RecordingStreamBuilder};
 
@@ -14,8 +14,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         ClassDescription {
             info: AnnotationInfo {
                 id: 1,
-                label: Some(Label("red".to_owned())),
-                color: Some(ColorRGBA::from_rgb(255, 0, 0)),
+                label: Some(Label("red".into()).into()),
+                color: Some(Color::from_rgb(255, 0, 0).into()),
             },
             ..Default::default()
         },
@@ -25,8 +25,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         ClassDescription {
             info: AnnotationInfo {
                 id: 2,
-                label: Some(Label("green".to_owned())),
-                color: Some(ColorRGBA::from_rgb(0, 255, 0)),
+                label: Some(Label("green".into()).into()),
+                color: Some(Color::from_rgb(0, 255, 0).into()),
             },
             ..Default::default()
         },
diff --git a/docs/code-examples/annotation_context_segmentation.rs b/docs/code-examples/annotation_context_segmentation.rs
index 433a0766f2e4..eb58354d82af 100644
--- a/docs/code-examples/annotation_context_segmentation.rs
+++ b/docs/code-examples/annotation_context_segmentation.rs
@@ -1,7 +1,7 @@
 //! Log a segmentation image with annotations.
 use ndarray::{s, Array, ShapeBuilder};
 use rerun::components::{
-    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, ColorRGBA, Label, Tensor,
+    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, Color, Label, Tensor,
     TensorDataMeaning,
 };
 use rerun::{MsgSender, RecordingStreamBuilder};
@@ -25,8 +25,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         ClassDescription {
             info: AnnotationInfo {
                 id: 1,
-                label: Some(Label("red".to_owned())),
-                color: Some(ColorRGBA::from_rgb(255, 0, 0)),
+                label: Some(Label("red".into()).into()),
+                color: Some(Color::from_rgb(255, 0, 0).into()),
             },
             ..Default::default()
         },
@@ -36,8 +36,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         ClassDescription {
             info: AnnotationInfo {
                 id: 2,
-                label: Some(Label("green".to_owned())),
-                color: Some(ColorRGBA::from_rgb(0, 255, 0)),
+                label: Some(Label("green".into()).into()),
+                color: Some(Color::from_rgb(0, 255, 0).into()),
             },
             ..Default::default()
         },
diff --git a/docs/code-examples/point2d_random.rs b/docs/code-examples/point2d_random.rs
index 575158be9715..a48e6e5b7cec 100644
--- a/docs/code-examples/point2d_random.rs
+++ b/docs/code-examples/point2d_random.rs
@@ -1,7 +1,7 @@
 //! Log some random points with color and radii.
 use rand::distributions::Uniform;
 use rand::Rng;
-use rerun::components::{ColorRGBA, Point2D, Radius, Rect2D, Vec4D};
+use rerun::components::{Color, Point2D, Radius, Rect2D, Vec4D};
 use rerun::{MsgSender, RecordingStreamBuilder};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -18,7 +18,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             rng.sample(position_distribs),
             rng.sample(position_distribs),
         ));
-        colors.push(ColorRGBA::from_rgb(rng.gen(), rng.gen(), rng.gen()));
+        colors.push(Color::from_rgb(rng.gen(), rng.gen(), rng.gen()));
         radii.push(Radius(rng.gen()));
     }
 
diff --git a/docs/code-examples/point2d_random_v2.rs b/docs/code-examples/point2d_random_v2.rs
index 5f8a7682af7b..21f10e511728 100644
--- a/docs/code-examples/point2d_random_v2.rs
+++ b/docs/code-examples/point2d_random_v2.rs
@@ -3,8 +3,8 @@
 use rand::distributions::Uniform;
 use rand::Rng;
 use rerun::{
-    components::{Rect2D, Vec4D},
-    experimental::{archetypes::Points2D, components::Color},
+    archetypes::Points2D,
+    components::{Color, Rect2D, Vec4D},
     MsgSender, RecordingStreamBuilder,
 };
 
diff --git a/docs/code-examples/point2d_simple_v2.rs b/docs/code-examples/point2d_simple_v2.rs
index 0fd9b62273a7..fa8512aa27ce 100644
--- a/docs/code-examples/point2d_simple_v2.rs
+++ b/docs/code-examples/point2d_simple_v2.rs
@@ -1,8 +1,8 @@
 //! Log some very simple points.
 
 use rerun::{
+    archetypes::Points2D,
     components::{Rect2D, Vec4D},
-    experimental::archetypes::Points2D,
     MsgSender, RecordingStreamBuilder,
 };
 
diff --git a/docs/code-examples/point3d_random.rs b/docs/code-examples/point3d_random.rs
index 52a3b8aeba12..4c34e81cec17 100644
--- a/docs/code-examples/point3d_random.rs
+++ b/docs/code-examples/point3d_random.rs
@@ -1,7 +1,7 @@
 //! Log some random points with color and radii."""
 use rand::distributions::Uniform;
 use rand::Rng;
-use rerun::components::{ColorRGBA, Point3D, Radius};
+use rerun::components::{Color, Point3D, Radius};
 use rerun::{MsgSender, RecordingStreamBuilder};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -19,7 +19,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             rng.sample(position_distribs),
             rng.sample(position_distribs),
         ));
-        colors.push(ColorRGBA::from_rgb(rng.gen(), rng.gen(), rng.gen()));
+        colors.push(Color::from_rgb(rng.gen(), rng.gen(), rng.gen()));
         radii.push(Radius(rng.gen()));
     }
 
diff --git a/docs/code-examples/point3d_random_v2.rs b/docs/code-examples/point3d_random_v2.rs
index 3838ab610c3f..021e4998a0b6 100644
--- a/docs/code-examples/point3d_random_v2.rs
+++ b/docs/code-examples/point3d_random_v2.rs
@@ -1,10 +1,7 @@
 //! Log some random points with color and radii."""
 use rand::distributions::Uniform;
 use rand::Rng;
-use rerun::{
-    experimental::{archetypes::Points3D, components::Color},
-    MsgSender, RecordingStreamBuilder,
-};
+use rerun::{archetypes::Points3D, components::Color, MsgSender, RecordingStreamBuilder};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (rec_stream, storage) = RecordingStreamBuilder::new("points").memory()?;
diff --git a/docs/code-examples/point3d_simple.rs b/docs/code-examples/point3d_simple.rs
index 8cbf6ec4263b..055ef9fe35d7 100644
--- a/docs/code-examples/point3d_simple.rs
+++ b/docs/code-examples/point3d_simple.rs
@@ -1,4 +1,5 @@
 //! Log some very simple points.
+
 use rerun::{components::Point3D, MsgSender, RecordingStreamBuilder};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/docs/code-examples/point3d_simple_v2.rs b/docs/code-examples/point3d_simple_v2.rs
index c249a6a0b193..f359e72e98c4 100644
--- a/docs/code-examples/point3d_simple_v2.rs
+++ b/docs/code-examples/point3d_simple_v2.rs
@@ -1,5 +1,5 @@
 //! Log some very simple points.
-use rerun::{experimental::archetypes::Points3D, MsgSender, RecordingStreamBuilder};
+use rerun::{archetypes::Points3D, MsgSender, RecordingStreamBuilder};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (rec_stream, storage) = RecordingStreamBuilder::new("points").memory()?;
diff --git a/docs/code-examples/segmentation_image_simple.rs b/docs/code-examples/segmentation_image_simple.rs
index f5b915f26af8..79ab04bbf306 100644
--- a/docs/code-examples/segmentation_image_simple.rs
+++ b/docs/code-examples/segmentation_image_simple.rs
@@ -1,7 +1,7 @@
 //! Create and log a segmentation image.
 use ndarray::{s, Array, ShapeBuilder};
 use rerun::components::{
-    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, ColorRGBA, Label, Tensor,
+    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, Color, Label, Tensor,
     TensorDataMeaning,
 };
 use rerun::{MsgSender, RecordingStreamBuilder};
@@ -24,8 +24,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         ClassDescription {
             info: AnnotationInfo {
                 id: 1,
-                label: Some(Label("red".to_owned())),
-                color: Some(ColorRGBA::from_rgb(255, 0, 0)),
+                label: Some(Label("red".into()).into()),
+                color: Some(Color::from_rgb(255, 0, 0).into()),
             },
             ..Default::default()
         },
@@ -35,8 +35,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         ClassDescription {
             info: AnnotationInfo {
                 id: 2,
-                label: Some(Label("green".to_owned())),
-                color: Some(ColorRGBA::from_rgb(0, 255, 0)),
+                label: Some(Label("green".into()).into()),
+                color: Some(Color::from_rgb(0, 255, 0).into()),
             },
             ..Default::default()
         },
diff --git a/docs/code-examples/transform3d_simple_v2.rs b/docs/code-examples/transform3d_simple_v2.rs
index ad14dde7ce6d..5ec6ba78fbb3 100644
--- a/docs/code-examples/transform3d_simple_v2.rs
+++ b/docs/code-examples/transform3d_simple_v2.rs
@@ -1,12 +1,9 @@
 //! Log some transforms.
 
 use rerun::{
-    experimental::{
-        archetypes::Transform3D,
-        datatypes::{
-            Angle, Mat3x3, RotationAxisAngle, Scale3D, TranslationAndMat3x3,
-            TranslationRotationScale3D,
-        },
+    archetypes::Transform3D,
+    datatypes::{
+        Angle, Mat3x3, RotationAxisAngle, Scale3D, TranslationAndMat3x3, TranslationRotationScale3D,
     },
     MsgSender, RecordingStreamBuilder,
 };
diff --git a/docs/content/getting-started/logging-rust.md b/docs/content/getting-started/logging-rust.md
index e3144684f262..fac1dbfeee20 100644
--- a/docs/content/getting-started/logging-rust.md
+++ b/docs/content/getting-started/logging-rust.md
@@ -34,7 +34,7 @@ use std::f32::consts::TAU;
 use itertools::Itertools as _;
 
 use rerun::{
-    components::{ColorRGBA, LineStrip3D, Point3D, Radius, Transform3D, Vec3D},
+    components::{Color, LineStrip3D, Point3D, Radius, Transform3D, Vec3D},
     demo_util::{bounce_lerp, color_spiral},
     external::glam,
     time::{Time, TimeType, Timeline},
@@ -85,13 +85,13 @@ let (points2, colors2) = color_spiral(NUM_POINTS, 2.0, 0.02, TAU * 0.5, 0.1);
 
 MsgSender::new("dna/structure/left")
     .with_component(&points1.iter().copied().map(Point3D::from).collect_vec())?
-    .with_component(&colors1.iter().copied().map(ColorRGBA::from).collect_vec())?
+    .with_component(&colors1.iter().copied().map(Color::from).collect_vec())?
     .with_splat(Radius(0.08))?
     .send(&recording)?;
 
 MsgSender::new("dna/structure/right")
     .with_component(&points2.iter().copied().map(Point3D::from).collect_vec())?
-    .with_component(&colors2.iter().copied().map(ColorRGBA::from).collect_vec())?
+    .with_component(&colors2.iter().copied().map(Color::from).collect_vec())?
     .with_splat(Radius(0.08))?
     .send(&recording)?;
 ```
@@ -148,7 +148,7 @@ let scaffolding = all_points
     .collect_vec();
 MsgSender::new("dna/structure/scaffolding")
     .with_component(&scaffolding)?
-    .with_splat(ColorRGBA::from([128, 128, 128, 255]))?
+    .with_splat(Color::from([128, 128, 128, 255]))?
     .send(&recording)?;
 ```
 
@@ -170,7 +170,7 @@ let (beads, colors): (Vec<_>, Vec<_>) = points1
         let c = bounce_lerp(80.0, 230.0, offsets[n] * 2.0) as u8;
         (
             Point3D::from(bounce_lerp(p1, p2, offsets[n])),
-            ColorRGBA::from_rgb(c, c, c),
+            Color::from_rgb(c, c, c),
         )
     })
     .unzip();
@@ -220,7 +220,7 @@ for i in 0..400 {
             let c = bounce_lerp(80.0, 230.0, times[n] * 2.0) as u8;
             (
                 Point3D::from(bounce_lerp(p1, p2, times[n])),
-                ColorRGBA::from_rgb(c, c, c),
+                Color::from_rgb(c, c, c),
             )
         })
         .unzip();
diff --git a/docs/content/getting-started/rust.md b/docs/content/getting-started/rust.md
index 952b7261d344..550ba144261d 100644
--- a/docs/content/getting-started/rust.md
+++ b/docs/content/getting-started/rust.md
@@ -21,7 +21,7 @@ Add the following code to your `main.rs`
 (This example also lives in the `rerun` source tree [example](https://github.com/rerun-io/rerun/tree/latest/examples/rust/minimal/src/main.rs))
 ```rust
 use rerun::{
-    components::{ColorRGBA, Point3D, Radius},
+    components::{Color, Point3D, Radius},
     demo_util::grid,
     external::glam,
     MsgSender, RecordingStreamBuilder,
@@ -35,7 +35,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map(Point3D::from)
         .collect::<Vec<_>>();
     let colors = grid(glam::Vec3::ZERO, glam::Vec3::splat(255.0), 10)
-        .map(|v| ColorRGBA::from_rgb(v.x as u8, v.y as u8, v.z as u8))
+        .map(|v| Color::from_rgb(v.x as u8, v.y as u8, v.z as u8))
         .collect::<Vec<_>>();
 
     MsgSender::new("my_points")
diff --git a/examples/python/human_pose_tracking/main.py b/examples/python/human_pose_tracking/main.py
index 72e4bc6dd0af..e14aac2a1cb7 100755
--- a/examples/python/human_pose_tracking/main.py
+++ b/examples/python/human_pose_tracking/main.py
@@ -50,10 +50,12 @@ def track_pose(video_path: str, segment: bool) -> None:
             results = pose.process(rgb)
             h, w, _ = rgb.shape
             landmark_positions_2d = read_landmark_positions_2d(results, w, h)
-            rr.log_points("video/pose/points", landmark_positions_2d, keypoint_ids=mp_pose.PoseLandmark)
+            if landmark_positions_2d is not None:
+                rr.log_points("video/pose/points", landmark_positions_2d, keypoint_ids=mp_pose.PoseLandmark)
 
             landmark_positions_3d = read_landmark_positions_3d(results)
-            rr.log_points("person/pose/points", landmark_positions_3d, keypoint_ids=mp_pose.PoseLandmark)
+            if landmark_positions_3d is not None:
+                rr.log_points("person/pose/points", landmark_positions_3d, keypoint_ids=mp_pose.PoseLandmark)
 
             segmentation_mask = results.segmentation_mask
             if segmentation_mask is not None:
diff --git a/examples/rust/clock/src/main.rs b/examples/rust/clock/src/main.rs
index 7b9d1c1aaef9..22f70ac12263 100644
--- a/examples/rust/clock/src/main.rs
+++ b/examples/rust/clock/src/main.rs
@@ -9,7 +9,7 @@
 
 use std::f32::consts::TAU;
 
-use rerun::components::{Arrow3D, Box3D, ColorRGBA, Radius, Vec3D, ViewCoordinates};
+use rerun::components::{Arrow3D, Box3D, Color, Radius, Vec3D, ViewCoordinates};
 use rerun::coordinates::SignedAxis3;
 use rerun::{external::re_log, MsgSender, RecordingStream};
 
@@ -49,9 +49,9 @@ fn run(rec_stream: &RecordingStream, args: &Args) -> anyhow::Result<()> {
         Vec3D::new(length * angle.sin(), length * angle.cos(), 0.0)
     }
 
-    fn color(angle: f32, blue: u8) -> ColorRGBA {
+    fn color(angle: f32, blue: u8) -> Color {
         let c = (angle * 255.0) as u8;
-        ColorRGBA::from_unmultiplied_rgba(255 - c, c, blue, u8::max(128, blue))
+        Color::from_unmultiplied_rgba(255 - c, c, blue, u8::max(128, blue))
     }
 
     fn log_hand(
diff --git a/examples/rust/custom_space_view/Cargo.toml b/examples/rust/custom_space_view/Cargo.toml
index 3cc0663ff715..8e12ed184bdc 100644
--- a/examples/rust/custom_space_view/Cargo.toml
+++ b/examples/rust/custom_space_view/Cargo.toml
@@ -13,6 +13,7 @@ default = []
 analytics = ["re_crash_handler/analytics", "re_viewer/analytics"]
 
 [dependencies]
+once_cell = "1.18"
 re_crash_handler = { path = "../../../crates/re_crash_handler" }
 re_viewer = { path = "../../../crates/re_viewer", default-features = false }
 
diff --git a/examples/rust/custom_space_view/src/color_coordinates_view_part_system.rs b/examples/rust/custom_space_view/src/color_coordinates_view_part_system.rs
index b1fb0cf21be0..414995ec26c1 100644
--- a/examples/rust/custom_space_view/src/color_coordinates_view_part_system.rs
+++ b/examples/rust/custom_space_view/src/color_coordinates_view_part_system.rs
@@ -1,9 +1,9 @@
 use re_viewer::external::{
-    egui, re_components,
+    egui,
     re_log_types::EntityPath,
-    re_query::query_entity_with_primary,
+    re_query::query_archetype,
     re_renderer,
-    re_types::{components::InstanceKey, Loggable as _},
+    re_types::{self, components::InstanceKey, Archetype, Loggable as _},
     re_viewer_context::{
         ArchetypeDefinition, SpaceViewSystemExecutionError, ViewContextCollection, ViewPartSystem,
         ViewQuery, ViewerContext,
@@ -21,13 +21,66 @@ pub struct ColorWithInstanceKey {
     pub instance_key: InstanceKey,
 }
 
+struct ColorArchetype;
+
+// TODO(#2778): The introduction of ArchetypeInfo should make this much much nicer.
+#[allow(clippy::unimplemented)]
+impl re_types::Archetype for ColorArchetype {
+    fn name() -> re_types::ArchetypeName {
+        "InstanceColor".into()
+    }
+
+    fn required_components() -> &'static [re_types::ComponentName] {
+        static COMPONENTS: once_cell::sync::Lazy<[re_types::ComponentName; 1]> =
+            once_cell::sync::Lazy::new(|| [re_types::components::Color::name()]);
+        &*COMPONENTS
+    }
+
+    fn recommended_components() -> &'static [re_types::ComponentName] {
+        &[]
+    }
+
+    fn optional_components() -> &'static [re_types::ComponentName] {
+        &[]
+    }
+
+    fn all_components() -> &'static [re_types::ComponentName] {
+        Self::required_components()
+    }
+
+    fn try_to_arrow(
+        &self,
+    ) -> re_types::SerializationResult<
+        Vec<(
+            re_viewer::external::arrow2::datatypes::Field,
+            Box<dyn re_viewer::external::arrow2::array::Array>,
+        )>,
+    > {
+        unimplemented!()
+    }
+
+    fn try_from_arrow(
+        _data: impl IntoIterator<
+            Item = (
+                re_viewer::external::arrow2::datatypes::Field,
+                Box<dyn re_viewer::external::arrow2::array::Array>,
+            ),
+        >,
+    ) -> re_viewer::external::re_types::DeserializationResult<Self>
+    where
+        Self: Sized,
+    {
+        unimplemented!()
+    }
+}
+
 impl ViewPartSystem for InstanceColorSystem {
     /// The archetype this scene part is querying from the store.
     ///
     /// TODO(wumpf): In future versions there will be a hard restriction that limits the queries
     ///              within the `populate` method to this archetype.
     fn archetype(&self) -> ArchetypeDefinition {
-        ArchetypeDefinition::new(re_components::ColorRGBA::name())
+        ColorArchetype::all_components().try_into().unwrap()
     }
 
     /// Populates the scene part with data from the store.
@@ -44,26 +97,25 @@ impl ViewPartSystem for InstanceColorSystem {
             }
 
             // ...gather all colors and their instance ids.
-            if let Ok(ent_view) = query_entity_with_primary::<re_components::ColorRGBA>(
+            if let Ok(arch_view) = query_archetype::<ColorArchetype>(
                 &ctx.store_db.entity_db.data_store,
                 &ctx.current_query(),
                 ent_path,
-                &[re_components::ColorRGBA::name()],
             ) {
-                if let Ok(primary_iterator) = ent_view.iter_primary() {
+                if let Ok(colors) =
+                    arch_view.iter_required_component::<re_types::components::Color>()
+                {
                     self.colors.push((
                         ent_path.clone(),
-                        ent_view
+                        arch_view
                             .iter_instance_keys()
-                            .zip(primary_iterator)
-                            .filter_map(|(instance_key, color)| {
-                                color.map(|color| {
-                                    let [r, g, b, _] = color.to_array();
-                                    ColorWithInstanceKey {
-                                        color: egui::Color32::from_rgb(r, g, b),
-                                        instance_key,
-                                    }
-                                })
+                            .zip(colors)
+                            .map(|(instance_key, color)| {
+                                let [r, g, b, _] = color.to_array();
+                                ColorWithInstanceKey {
+                                    color: egui::Color32::from_rgb(r, g, b),
+                                    instance_key,
+                                }
                             })
                             .collect(),
                     ));
diff --git a/examples/rust/dna/src/main.rs b/examples/rust/dna/src/main.rs
index 6506821f2ae5..65dbb76c3168 100644
--- a/examples/rust/dna/src/main.rs
+++ b/examples/rust/dna/src/main.rs
@@ -5,7 +5,7 @@ use std::f32::consts::TAU;
 use itertools::Itertools as _;
 
 use rerun::{
-    components::{ColorRGBA, LineStrip3D, Point3D, Radius, Transform3D, Vec3D},
+    components::{Color, LineStrip3D, Point3D, Radius, Transform3D, Vec3D},
     demo_util::{bounce_lerp, color_spiral},
     external::glam,
     MsgSender, MsgSenderError, RecordingStream,
@@ -29,13 +29,13 @@ fn run(rec_stream: &RecordingStream) -> Result<(), MsgSenderError> {
 
     MsgSender::new("dna/structure/left")
         .with_component(&points1.iter().copied().map(Point3D::from).collect_vec())?
-        .with_component(&colors1.iter().copied().map(ColorRGBA::from).collect_vec())?
+        .with_component(&colors1.iter().copied().map(Color::from).collect_vec())?
         .with_splat(Radius(0.08))?
         .send(rec_stream)?;
 
     MsgSender::new("dna/structure/right")
         .with_component(&points2.iter().copied().map(Point3D::from).collect_vec())?
-        .with_component(&colors2.iter().copied().map(ColorRGBA::from).collect_vec())?
+        .with_component(&colors2.iter().copied().map(Color::from).collect_vec())?
         .with_splat(Radius(0.08))?
         .send(rec_stream)?;
 
@@ -50,7 +50,7 @@ fn run(rec_stream: &RecordingStream) -> Result<(), MsgSenderError> {
         .collect_vec();
     MsgSender::new("dna/structure/scaffolding")
         .with_component(&scaffolding)?
-        .with_splat(ColorRGBA::from([128, 128, 128, 255]))?
+        .with_splat(Color::from([128, 128, 128, 255]))?
         .send(rec_stream)?;
 
     use rand::Rng as _;
@@ -75,7 +75,7 @@ fn run(rec_stream: &RecordingStream) -> Result<(), MsgSenderError> {
                 let c = bounce_lerp(80.0, 230.0, times[n] * 2.0) as u8;
                 (
                     Point3D::from(bounce_lerp(p1, p2, times[n])),
-                    ColorRGBA::from_rgb(c, c, c),
+                    Color::from_rgb(c, c, c),
                 )
             })
             .unzip();
diff --git a/examples/rust/minimal/src/main.rs b/examples/rust/minimal/src/main.rs
index 6c54f7246079..af30703354a3 100644
--- a/examples/rust/minimal/src/main.rs
+++ b/examples/rust/minimal/src/main.rs
@@ -1,7 +1,7 @@
 //! Demonstrates the most barebone usage of the Rerun SDK.
 
 use rerun::{
-    components::{ColorRGBA, Point3D, Radius},
+    components::{Color, Point3D, Radius},
     demo_util::grid,
     external::glam,
     MsgSender, RecordingStreamBuilder,
@@ -14,7 +14,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map(Point3D::from)
         .collect::<Vec<_>>();
     let colors = grid(glam::Vec3::ZERO, glam::Vec3::splat(255.0), 10)
-        .map(|v| ColorRGBA::from_rgb(v.x as u8, v.y as u8, v.z as u8))
+        .map(|v| Color::from_rgb(v.x as u8, v.y as u8, v.z as u8))
         .collect::<Vec<_>>();
 
     MsgSender::new("my_points")
diff --git a/examples/rust/minimal_options/src/main.rs b/examples/rust/minimal_options/src/main.rs
index 600fe3c6559f..799794ff9736 100644
--- a/examples/rust/minimal_options/src/main.rs
+++ b/examples/rust/minimal_options/src/main.rs
@@ -5,7 +5,7 @@
 //!  cargo run -p minimal_options -- --help
 //! ```
 
-use rerun::components::{ColorRGBA, Point3D, Radius};
+use rerun::components::{Color, Point3D, Radius};
 use rerun::{external::re_log, MsgSender, RecordingStream};
 
 use rerun::demo_util::grid;
@@ -36,7 +36,7 @@ fn run(rec_stream: &RecordingStream, args: &Args) -> anyhow::Result<()> {
         glam::Vec3::splat(255.0),
         args.num_points_per_axis,
     )
-    .map(|v| ColorRGBA::from_rgb(v.x as u8, v.y as u8, v.z as u8))
+    .map(|v| Color::from_rgb(v.x as u8, v.y as u8, v.z as u8))
     .collect::<Vec<_>>();
 
     rec_stream.set_time_sequence("keyframe", 0);
diff --git a/examples/rust/minimal_serve/src/main.rs b/examples/rust/minimal_serve/src/main.rs
index a363e083fd32..36fb07bda47d 100644
--- a/examples/rust/minimal_serve/src/main.rs
+++ b/examples/rust/minimal_serve/src/main.rs
@@ -1,7 +1,7 @@
 //! Demonstrates the most barebone usage of the Rerun SDK.
 
 use rerun::{
-    components::{ColorRGBA, Point3D, Radius},
+    components::{Color, Point3D, Radius},
     demo_util::grid,
     external::glam,
     MsgSender, RecordingStreamBuilder,
@@ -23,7 +23,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map(Point3D::from)
         .collect::<Vec<_>>();
     let colors = grid(glam::Vec3::ZERO, glam::Vec3::splat(255.0), 10)
-        .map(|v| ColorRGBA::from_rgb(v.x as u8, v.y as u8, v.z as u8))
+        .map(|v| Color::from_rgb(v.x as u8, v.y as u8, v.z as u8))
         .collect::<Vec<_>>();
 
     MsgSender::new("my_points")
diff --git a/examples/rust/objectron/src/main.rs b/examples/rust/objectron/src/main.rs
index 383a3956a42d..21acb4507321 100644
--- a/examples/rust/objectron/src/main.rs
+++ b/examples/rust/objectron/src/main.rs
@@ -113,7 +113,7 @@ fn log_baseline_objects(
     rec_stream: &RecordingStream,
     objects: &[objectron::Object],
 ) -> anyhow::Result<()> {
-    use rerun::components::{Box3D, ColorRGBA, Label, Transform3D};
+    use rerun::components::{Box3D, Color, Label, Transform3D};
     use rerun::transform::TranslationAndMat3;
 
     let boxes = objects.iter().filter_map(|object| {
@@ -142,7 +142,7 @@ fn log_baseline_objects(
             .with_component(&[bbox])?
             .with_component(&[transform])?
             .with_component(&[label])?
-            .with_splat(ColorRGBA::from_rgb(160, 230, 130))?
+            .with_splat(Color::from_rgb(160, 230, 130))?
             .send(rec_stream)?;
     }
 
@@ -214,7 +214,7 @@ fn log_feature_points(
     timepoint: TimePoint,
     points: &objectron::ArPointCloud,
 ) -> anyhow::Result<()> {
-    use rerun::components::{ColorRGBA, InstanceKey, Point3D};
+    use rerun::components::{Color, InstanceKey, Point3D};
 
     let ids = points.identifier.iter();
     let points = points.point.iter();
@@ -236,7 +236,7 @@ fn log_feature_points(
         .with_timepoint(timepoint)
         .with_component(&points)?
         .with_component(&ids)?
-        .with_splat(ColorRGBA::from_rgb(255, 255, 255))?
+        .with_splat(Color::from_rgb(255, 255, 255))?
         .send(rec_stream)?;
 
     Ok(())
@@ -247,7 +247,7 @@ fn log_frame_annotations(
     timepoint: &TimePoint,
     annotations: &objectron::FrameAnnotation,
 ) -> anyhow::Result<()> {
-    use rerun::components::{ColorRGBA, InstanceKey, LineStrip2D, Point2D};
+    use rerun::components::{Color, InstanceKey, LineStrip2D, Point2D};
 
     for ann in &annotations.annotations {
         // TODO(cmc): we shouldn't be using those preprojected 2D points to begin with, Rerun is
@@ -264,7 +264,7 @@ fn log_frame_annotations(
 
         let mut msg = MsgSender::new(format!("world/camera/estimates/box-{}", ann.object_id))
             .with_timepoint(timepoint.clone())
-            .with_splat(ColorRGBA::from_rgb(130, 160, 250))?;
+            .with_splat(Color::from_rgb(130, 160, 250))?;
 
         if points.len() == 9 {
             // Build the preprojected bounding box out of 2D line segments.
diff --git a/examples/rust/raw_mesh/src/main.rs b/examples/rust/raw_mesh/src/main.rs
index a605ca396290..ccef8bc2780e 100644
--- a/examples/rust/raw_mesh/src/main.rs
+++ b/examples/rust/raw_mesh/src/main.rs
@@ -12,9 +12,7 @@ use std::path::PathBuf;
 
 use anyhow::anyhow;
 use bytes::Bytes;
-use rerun::components::{
-    ColorRGBA, Mesh3D, MeshId, RawMesh3D, Transform3D, Vec4D, ViewCoordinates,
-};
+use rerun::components::{Color, Mesh3D, MeshId, RawMesh3D, Transform3D, Vec4D, ViewCoordinates};
 use rerun::transform::TranslationRotationScale3D;
 use rerun::{
     external::{re_log, re_memory::AccountingAllocator},
@@ -210,7 +208,7 @@ struct GltfPrimitive {
     albedo_factor: Option<[f32; 4]>,
     indices: Option<Vec<u32>>,
     vertex_positions: Vec<[f32; 3]>,
-    vertex_colors: Option<Vec<ColorRGBA>>,
+    vertex_colors: Option<Vec<Color>>,
     vertex_normals: Option<Vec<[f32; 3]>>,
     #[allow(dead_code)]
     vertex_texcoords: Option<Vec<[f32; 2]>>,
@@ -281,7 +279,7 @@ fn node_primitives<'data>(
             let vertex_colors = vertex_colors.map(|colors| {
                 colors
                     .into_rgba_u8()
-                    .map(|[r, g, b, a]| ColorRGBA::from_unmultiplied_rgba(r, g, b, a))
+                    .map(|[r, g, b, a]| Color::from_unmultiplied_rgba(r, g, b, a))
                     .collect()
             });
 
diff --git a/rerun_py/rerun_sdk/rerun/components/__init__.py b/rerun_py/rerun_sdk/rerun/components/__init__.py
index 983b41c21bfd..0ef34e2dc9e1 100644
--- a/rerun_py/rerun_sdk/rerun/components/__init__.py
+++ b/rerun_py/rerun_sdk/rerun/components/__init__.py
@@ -8,20 +8,16 @@
 from rerun import bindings
 
 all = [
-    "annotation",
     "arrow",
     "box",
-    "color",
     "draw_order",
     "experimental",
-    "label",
     "pinhole",
-    "point",
     "quaternion",
-    "radius",
     "rect2d",
     "scalar_plot_props",
     "scalar",
+    "splat",
     "tensor",
     "text_entry",
     "vec",
@@ -104,3 +100,13 @@ def build_dense_union(data_type: pa.DenseUnionType, discriminant: str, child: pa
 
     except ValueError as e:
         raise ValueError(e.args)
+
+
+# NOTE: This has to live here for now, while we migrate to archetypes (circular experimental imports).
+def splat() -> Any:
+    """Helper to generate a splat InstanceKeyArray."""
+
+    from rerun.experimental import cmp as rrc
+
+    _MAX_U64 = 2**64 - 1
+    return pa.array([_MAX_U64], type=rrc.InstanceKeyType().storage_type)  # type: ignore[no-any-return]
diff --git a/rerun_py/rerun_sdk/rerun/components/annotation.py b/rerun_py/rerun_sdk/rerun/components/annotation.py
deleted file mode 100644
index c622fb5489f0..000000000000
--- a/rerun_py/rerun_sdk/rerun/components/annotation.py
+++ /dev/null
@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-import numpy.typing as npt
-import pyarrow as pa
-
-from rerun.components import REGISTERED_COMPONENT_NAMES, ComponentTypeFactory
-
-__all__ = [
-    "ClassIdArray",
-    "ClassIdType",
-    "KeypointIdArray",
-    "KeypointIdType",
-]
-
-
-class ClassIdArray(pa.ExtensionArray):  # type: ignore[misc]
-    def from_numpy(array: npt.NDArray[np.uint16]) -> ClassIdArray:
-        """Build a `ClassIdArray` from an Nx1 numpy array."""
-        assert len(array.shape) == 1
-
-        storage = pa.array(array, type=ClassIdType.storage_type)
-        # TODO(john) enable extension type wrapper
-        # return cast(ClassIdArray, pa.ExtensionArray.from_storage(ClassIdArray(), storage))
-        return storage  # type: ignore[no-any-return]
-
-
-ClassIdType = ComponentTypeFactory("ClassIdType", ClassIdArray, REGISTERED_COMPONENT_NAMES["rerun.class_id"])
-
-
-class KeypointIdArray(pa.ExtensionArray):  # type: ignore[misc]
-    def from_numpy(array: npt.NDArray[np.uint16]) -> KeypointIdArray:
-        """Build a `KeypointIdArray` from an Nx1 numpy array."""
-        assert len(array.shape) == 1
-
-        storage = pa.array(array, type=KeypointIdType.storage_type)
-        # TODO(john) enable extension type wrapper
-        # return cast(KeypointIdArray, pa.ExtensionArray.from_storage(KeypointIdArray(), storage))
-        return storage  # type: ignore[no-any-return]
-
-
-KeypointIdType = ComponentTypeFactory("KeypointIdType", ClassIdArray, REGISTERED_COMPONENT_NAMES["rerun.keypoint_id"])
-
-pa.register_extension_type(ClassIdType())
diff --git a/rerun_py/rerun_sdk/rerun/components/color.py b/rerun_py/rerun_sdk/rerun/components/color.py
deleted file mode 100644
index b980d7616ab4..000000000000
--- a/rerun_py/rerun_sdk/rerun/components/color.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-import numpy.typing as npt
-import pyarrow as pa
-
-from rerun.color_conversion import u8_array_to_rgba
-from rerun.components import REGISTERED_COMPONENT_NAMES, ComponentTypeFactory
-
-__all__ = [
-    "ColorRGBAArray",
-    "ColorRGBAType",
-]
-
-
-class ColorRGBAArray(pa.ExtensionArray):  # type: ignore[misc]
-    def from_numpy(array: npt.NDArray[np.uint8]) -> ColorRGBAArray:
-        """Build a `ColorRGBAArray` from an numpy array."""
-        if array.ndim == 1:
-            array = np.reshape(array, (1, -1))
-        storage = pa.array(u8_array_to_rgba(array), type=ColorRGBAType.storage_type)
-        # TODO(john) enable extension type wrapper
-        # return cast(ColorRGBAArray, pa.ExtensionArray.from_storage(ColorRGBAType(), storage))
-        return storage  # type: ignore[no-any-return]
-
-
-ColorRGBAType = ComponentTypeFactory("ColorRGBAType", ColorRGBAArray, REGISTERED_COMPONENT_NAMES["rerun.colorrgba"])
-
-pa.register_extension_type(ColorRGBAType())
diff --git a/rerun_py/rerun_sdk/rerun/components/instance.py b/rerun_py/rerun_sdk/rerun/components/instance.py
deleted file mode 100644
index 428d339a72cd..000000000000
--- a/rerun_py/rerun_sdk/rerun/components/instance.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-import numpy.typing as npt
-import pyarrow as pa
-
-from rerun.components import REGISTERED_COMPONENT_NAMES, ComponentTypeFactory
-
-__all__ = [
-    "InstanceArray",
-    "InstanceType",
-]
-
-MAX_U64 = 2**64 - 1
-
-
-class InstanceArray(pa.ExtensionArray):  # type: ignore[misc]
-    def from_numpy(array: npt.NDArray[np.uint64]) -> InstanceArray:
-        """Build a `InstanceArray` from an numpy array."""
-        storage = pa.array(array, type=InstanceType.storage_type)
-        # TODO(john) enable extension type wrapper
-        # return cast(InstanceArray, pa.ExtensionArray.from_storage(InstanceType(), storage))
-        return storage  # type: ignore[no-any-return]
-
-    def splat() -> InstanceArray:  # type: ignore[misc]
-        storage = pa.array([MAX_U64], type=InstanceType.storage_type)
-        return storage  # type: ignore[no-any-return]
-
-
-InstanceType = ComponentTypeFactory("InstanceType", InstanceArray, REGISTERED_COMPONENT_NAMES["rerun.instance_key"])
-
-pa.register_extension_type(InstanceType())
diff --git a/rerun_py/rerun_sdk/rerun/components/label.py b/rerun_py/rerun_sdk/rerun/components/label.py
deleted file mode 100644
index dbafbfee770a..000000000000
--- a/rerun_py/rerun_sdk/rerun/components/label.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from typing import Sequence
-
-import pyarrow as pa
-
-from rerun.components import REGISTERED_COMPONENT_NAMES, ComponentTypeFactory
-
-__all__ = [
-    "LabelArray",
-    "LabelType",
-]
-
-
-class LabelArray(pa.ExtensionArray):  # type: ignore[misc]
-    def new(labels: Sequence[str]) -> LabelArray:
-        """Build a `LabelArray` from a sequence of str."""
-        storage = pa.array(labels, type=LabelType.storage_type)
-        # TODO(john) enable extension type wrapper
-        # return cast(LabelArray, pa.ExtensionArray.from_storage(LabelType(), storage))
-        return storage  # type: ignore[no-any-return]
-
-
-LabelType = ComponentTypeFactory("LabelType", LabelArray, REGISTERED_COMPONENT_NAMES["rerun.label"])
-
-pa.register_extension_type(LabelType())
diff --git a/rerun_py/rerun_sdk/rerun/components/point.py b/rerun_py/rerun_sdk/rerun/components/point.py
deleted file mode 100644
index 120c8506ba1f..000000000000
--- a/rerun_py/rerun_sdk/rerun/components/point.py
+++ /dev/null
@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-import numpy.typing as npt
-import pyarrow as pa
-
-from rerun.components import REGISTERED_COMPONENT_NAMES, ComponentTypeFactory
-
-__all__ = [
-    "Point2DArray",
-    "Point3DArray",
-    "Point2DType",
-    "Point3DType",
-]
-
-
-class Point2DArray(pa.ExtensionArray):  # type: ignore[misc]
-    def from_numpy(array: npt.NDArray[np.float32]) -> Point2DArray:
-        """Build a `Point2DArray` from an Nx2 numpy array."""
-        assert array.shape[1] == 2
-
-        points = np.asarray(array, dtype="float32")
-        storage = pa.StructArray.from_arrays(
-            arrays=[pa.array(c, type=pa.float32()) for c in points.T],
-            fields=list(Point2DType.storage_type),
-        )
-        # TODO(john) enable extension type wrapper
-        # return cast(Point2DArray, pa.ExtensionArray.from_storage(Point2DType(), storage))
-        return storage  # type: ignore[no-any-return]
-
-
-Point2DType = ComponentTypeFactory("Point2DType", Point2DArray, REGISTERED_COMPONENT_NAMES["rerun.point2d"])
-
-pa.register_extension_type(Point2DType())
-
-
-class Point3DArray(pa.ExtensionArray):  # type: ignore[misc]
-    def from_numpy(array: npt.NDArray[np.float32]) -> Point3DArray:
-        """Build a `Point3DArray` from an Nx3 numpy array."""
-        assert array.shape[1] == 3
-
-        points = np.asarray(array, dtype="float32")
-        storage = pa.StructArray.from_arrays(
-            arrays=[pa.array(c, type=pa.float32()) for c in points.T],
-            fields=list(Point3DType.storage_type),
-        )
-        # TODO(john) enable extension type wrapper
-        # return cast(Point3DArray, pa.ExtensionArray.from_storage(Point3DType(), storage))
-        return storage  # type: ignore[no-any-return]
-
-
-Point3DType = ComponentTypeFactory("Point3DType", Point3DArray, REGISTERED_COMPONENT_NAMES["rerun.point3d"])
-
-pa.register_extension_type(Point3DType())
diff --git a/rerun_py/rerun_sdk/rerun/components/radius.py b/rerun_py/rerun_sdk/rerun/components/radius.py
deleted file mode 100644
index 47203588871a..000000000000
--- a/rerun_py/rerun_sdk/rerun/components/radius.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-import numpy.typing as npt
-import pyarrow as pa
-
-from rerun.components import REGISTERED_COMPONENT_NAMES, ComponentTypeFactory
-
-__all__ = [
-    "RadiusArray",
-    "RadiusType",
-]
-
-
-class RadiusArray(pa.ExtensionArray):  # type: ignore[misc]
-    def from_numpy(array: npt.NDArray[np.float32]) -> RadiusArray:
-        """Build a `RadiusArray` from an numpy array."""
-        storage = pa.array(array, type=RadiusType.storage_type)
-        # TODO(john) enable extension type wrapper
-        # return cast(RadiusArray, pa.ExtensionArray.from_storage(RadiusType(), storage))
-        return storage  # type: ignore[no-any-return]
-
-
-RadiusType = ComponentTypeFactory("RadiusType", RadiusArray, REGISTERED_COMPONENT_NAMES["rerun.radius"])
-
-pa.register_extension_type(RadiusType())
diff --git a/rerun_py/rerun_sdk/rerun/log/arrow.py b/rerun_py/rerun_sdk/rerun/log/arrow.py
index 9b212693d1af..865c9ebaf5c1 100644
--- a/rerun_py/rerun_sdk/rerun/log/arrow.py
+++ b/rerun_py/rerun_sdk/rerun/log/arrow.py
@@ -6,11 +6,8 @@
 import numpy.typing as npt
 
 from rerun import bindings
+from rerun.components import splat
 from rerun.components.arrow import Arrow3DArray
-from rerun.components.color import ColorRGBAArray
-from rerun.components.instance import InstanceArray
-from rerun.components.label import LabelArray
-from rerun.components.radius import RadiusArray
 from rerun.log import Color, _normalize_colors, _normalize_radii
 from rerun.log.extension_components import _add_extension_components
 from rerun.log.log_decorator import log_decorator
@@ -67,6 +64,7 @@ def log_arrow(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
 
     instanced: dict[str, Any] = {}
     splats: dict[str, Any] = {}
@@ -80,20 +78,20 @@ def log_arrow(
 
     if color is not None:
         colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        instanced["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     if label:
-        instanced["rerun.label"] = LabelArray.new([label])
+        instanced["rerun.label"] = rrc.LabelArray.from_similar([label])
 
     if width_scale:
         radii = _normalize_radii([width_scale / 2])
-        instanced["rerun.radius"] = RadiusArray.from_numpy(radii)
+        instanced["rerun.radius"] = rrc.RadiusArray.from_similar(radii)
 
     if ext:
         _add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(
             entity_path,
             components=splats,
diff --git a/rerun_py/rerun_sdk/rerun/log/bounding_box.py b/rerun_py/rerun_sdk/rerun/log/bounding_box.py
index 72d5413d9ce8..4339d2396c73 100644
--- a/rerun_py/rerun_sdk/rerun/log/bounding_box.py
+++ b/rerun_py/rerun_sdk/rerun/log/bounding_box.py
@@ -6,13 +6,9 @@
 import numpy.typing as npt
 
 from rerun import bindings
-from rerun.components.annotation import ClassIdArray
+from rerun.components import splat
 from rerun.components.box import Box3DArray
-from rerun.components.color import ColorRGBAArray
-from rerun.components.instance import InstanceArray
-from rerun.components.label import LabelArray
 from rerun.components.quaternion import QuaternionArray
-from rerun.components.radius import RadiusArray
 from rerun.components.vec import Vec3DArray
 from rerun.log import (
     Color,
@@ -85,6 +81,8 @@ def log_obb(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     instanced: dict[str, Any] = {}
@@ -116,25 +114,25 @@ def log_obb(
 
     if color is not None:
         colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        instanced["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     # We store the stroke_width in radius
     if stroke_width:
         radii = _normalize_radii([stroke_width / 2])
-        instanced["rerun.radius"] = RadiusArray.from_numpy(radii)
+        instanced["rerun.radius"] = rrc.RadiusArray.from_similar(radii)
 
     if label:
-        instanced["rerun.label"] = LabelArray.new([label])
+        instanced["rerun.label"] = rrc.LabelArray.from_similar([label])
 
     if class_id:
         class_ids = _normalize_ids([class_id])
-        instanced["rerun.class_id"] = ClassIdArray.from_numpy(class_ids)
+        instanced["rerun.class_id"] = rrc.ClassIdArray.from_similar(class_ids)
 
     if ext:
         _add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(
             entity_path,
             components=splats,
@@ -200,6 +198,8 @@ def log_obbs(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     colors = _normalize_colors(colors)
@@ -239,25 +239,25 @@ def log_obbs(
         is_splat = len(colors.shape) == 1
         if is_splat:
             colors = colors.reshape(1, len(colors))
-        comps[is_splat]["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        comps[is_splat]["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     if len(radii):
         is_splat = len(radii) == 1
-        comps[is_splat]["rerun.radius"] = RadiusArray.from_numpy(radii)
+        comps[is_splat]["rerun.radius"] = rrc.RadiusArray.from_similar(radii)
 
     if len(labels):
         is_splat = len(labels) == 1
-        comps[is_splat]["rerun.label"] = LabelArray.new(labels)
+        comps[is_splat]["rerun.label"] = rrc.LabelArray.from_similar(labels)
 
     if len(class_ids):
         is_splat = len(class_ids) == 1
-        comps[is_splat]["rerun.class_id"] = ClassIdArray.from_numpy(class_ids)
+        comps[is_splat]["rerun.class_id"] = rrc.ClassIdArray.from_similar(class_ids)
 
     if ext:
         _add_extension_components(comps[0], comps[1], ext, None)
 
     if comps[1]:
-        comps[1]["rerun.instance_key"] = InstanceArray.splat()
+        comps[1]["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=comps[1], timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
diff --git a/rerun_py/rerun_sdk/rerun/log/experimental/text.py b/rerun_py/rerun_sdk/rerun/log/experimental/text.py
index 1e75ecbcb38b..b19aa78448b6 100644
--- a/rerun_py/rerun_sdk/rerun/log/experimental/text.py
+++ b/rerun_py/rerun_sdk/rerun/log/experimental/text.py
@@ -5,8 +5,8 @@
 
 import rerun.log.extension_components
 from rerun import bindings
+from rerun.components import splat
 from rerun.components.experimental.text_box import TextBoxArray
-from rerun.components.instance import InstanceArray
 from rerun.log.log_decorator import log_decorator
 
 # Fully qualified to avoid circular import
@@ -49,7 +49,7 @@ def log_text_box(
         rerun.log.extension_components._add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=splats, timeless=timeless)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
diff --git a/rerun_py/rerun_sdk/rerun/log/extension_components.py b/rerun_py/rerun_sdk/rerun/log/extension_components.py
index 1580bdd95799..9096dfa9e66f 100644
--- a/rerun_py/rerun_sdk/rerun/log/extension_components.py
+++ b/rerun_py/rerun_sdk/rerun/log/extension_components.py
@@ -8,7 +8,7 @@
 
 import rerun.log.error_utils
 from rerun import bindings
-from rerun.components.instance import InstanceArray
+from rerun.components import splat
 from rerun.log.log_decorator import log_decorator
 from rerun.recording_stream import RecordingStream
 
@@ -119,6 +119,8 @@ def log_extension_components(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     identifiers_np = np.array((), dtype="uint64")
@@ -133,12 +135,12 @@ def log_extension_components(
     splats: dict[str, Any] = {}
 
     if len(identifiers_np):
-        instanced["rerun.instance_key"] = InstanceArray.from_numpy(identifiers_np)
+        instanced["rerun.instance_key"] = rrc.InstanceKeyArray.from_similar(identifiers_np)
 
     _add_extension_components(instanced, splats, ext, identifiers_np)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=splats, timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
diff --git a/rerun_py/rerun_sdk/rerun/log/lines.py b/rerun_py/rerun_sdk/rerun/log/lines.py
index ec8a56aee0bc..990c4033065c 100644
--- a/rerun_py/rerun_sdk/rerun/log/lines.py
+++ b/rerun_py/rerun_sdk/rerun/log/lines.py
@@ -7,11 +7,9 @@
 from deprecated import deprecated
 
 from rerun import bindings
-from rerun.components.color import ColorRGBAArray
+from rerun.components import splat
 from rerun.components.draw_order import DrawOrderArray
-from rerun.components.instance import InstanceArray
 from rerun.components.linestrip import LineStrip2DArray, LineStrip3DArray
-from rerun.components.radius import RadiusArray
 from rerun.log import Color, Colors, _normalize_colors, _normalize_radii
 from rerun.log.error_utils import _send_warning
 from rerun.log.extension_components import _add_extension_components
@@ -92,6 +90,8 @@ def log_line_strip(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     if positions is not None:
@@ -110,12 +110,12 @@ def log_line_strip(
 
     if color is not None:
         colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        instanced["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     # We store the stroke_width in radius
     if stroke_width:
         radii = _normalize_radii([stroke_width / 2])
-        instanced["rerun.radius"] = RadiusArray.from_numpy(radii)
+        instanced["rerun.radius"] = rrc.RadiusArray.from_similar(radii)
 
     if draw_order is not None:
         instanced["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
@@ -124,7 +124,7 @@ def log_line_strip(
         _add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=splats, timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
@@ -187,6 +187,8 @@ def log_line_strips_2d(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     colors = _normalize_colors(colors)
@@ -213,18 +215,20 @@ def log_line_strips_2d(
         comps[0]["rerun.linestrip2d"] = LineStrip2DArray.from_numpy_arrays(line_strip_arrs)
 
     if len(identifiers_np):
-        comps[0]["rerun.instance_key"] = InstanceArray.from_numpy(identifiers_np)
+        comps[0]["rerun.instance_key"] = rrc.InstanceKeyArray.from_similar(identifiers_np)
 
     if len(colors):
+        from rerun.experimental import cmp as rrc
+
         is_splat = len(colors.shape) == 1
         if is_splat:
             colors = colors.reshape(1, len(colors))
-        comps[is_splat]["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        comps[is_splat]["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     # We store the stroke_width in radius
     if len(radii):
         is_splat = len(radii) == 1
-        comps[is_splat]["rerun.radius"] = RadiusArray.from_numpy(radii)
+        comps[is_splat]["rerun.radius"] = rrc.RadiusArray.from_similar(radii)
 
     if draw_order is not None:
         comps[1]["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
@@ -233,7 +237,7 @@ def log_line_strips_2d(
         _add_extension_components(comps[0], comps[1], ext, identifiers_np)
 
     if comps[1]:
-        comps[1]["rerun.instance_key"] = InstanceArray.splat()
+        comps[1]["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=comps[1], timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
@@ -295,6 +299,8 @@ def log_line_strips_3d(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     colors = _normalize_colors(colors)
@@ -321,18 +327,20 @@ def log_line_strips_3d(
         comps[0]["rerun.linestrip3d"] = LineStrip3DArray.from_numpy_arrays(line_strip_arrs)
 
     if len(identifiers_np):
-        comps[0]["rerun.instance_key"] = InstanceArray.from_numpy(identifiers_np)
+        comps[0]["rerun.instance_key"] = rrc.InstanceKeyArray.from_similar(identifiers_np)
 
     if len(colors):
+        from rerun.experimental import cmp as rrc
+
         is_splat = len(colors.shape) == 1
         if is_splat:
             colors = colors.reshape(1, len(colors))
-        comps[is_splat]["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        comps[is_splat]["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     # We store the stroke_width in radius
     if len(radii):
         is_splat = len(radii) == 1
-        comps[is_splat]["rerun.radius"] = RadiusArray.from_numpy(radii)
+        comps[is_splat]["rerun.radius"] = rrc.RadiusArray.from_similar(radii)
 
     if draw_order is not None:
         comps[1]["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
@@ -341,7 +349,7 @@ def log_line_strips_3d(
         _add_extension_components(comps[0], comps[1], ext, identifiers_np)
 
     if comps[1]:
-        comps[1]["rerun.instance_key"] = InstanceArray.splat()
+        comps[1]["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=comps[1], timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
@@ -396,6 +404,8 @@ def log_line_segments(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     if positions is None:
@@ -426,12 +436,12 @@ def log_line_segments(
     # require that we do so.
     if color is not None:
         colors = _normalize_colors(color)
-        splats["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        splats["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     # We store the stroke_width in radius
     if stroke_width:
         radii = _normalize_radii([stroke_width / 2])
-        splats["rerun.radius"] = RadiusArray.from_numpy(radii)
+        splats["rerun.radius"] = rrc.RadiusArray.from_similar(radii)
 
     if draw_order is not None:
         instanced["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
@@ -440,7 +450,7 @@ def log_line_segments(
         _add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=splats, timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
diff --git a/rerun_py/rerun_sdk/rerun/log/points.py b/rerun_py/rerun_sdk/rerun/log/points.py
index ceb6233ceca5..1b98e24d3238 100644
--- a/rerun_py/rerun_sdk/rerun/log/points.py
+++ b/rerun_py/rerun_sdk/rerun/log/points.py
@@ -5,26 +5,13 @@
 import numpy as np
 import numpy.typing as npt
 
-from rerun import bindings
-from rerun.components.annotation import ClassIdArray
-from rerun.components.color import ColorRGBAArray
-from rerun.components.draw_order import DrawOrderArray
-from rerun.components.instance import InstanceArray
-from rerun.components.label import LabelArray
-from rerun.components.point import Point2DArray, Point3DArray
-from rerun.components.radius import RadiusArray
 from rerun.log import (
     Color,
     Colors,
     OptionalClassIds,
     OptionalKeyPointIds,
-    _normalize_colors,
-    _normalize_ids,
-    _normalize_labels,
-    _normalize_radii,
 )
 from rerun.log.error_utils import _send_warning
-from rerun.log.extension_components import _add_extension_components
 from rerun.log.log_decorator import log_decorator
 from rerun.recording_stream import RecordingStream
 
@@ -37,7 +24,7 @@
 @log_decorator
 def log_point(
     entity_path: str,
-    position: npt.ArrayLike | None = None,
+    position: npt.ArrayLike,
     *,
     radius: float | None = None,
     color: Color | None = None,
@@ -98,58 +85,48 @@ def log_point(
         If left unspecified, defaults to the current active data recording, if there is one.
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
     """
+    from rerun.experimental import Points2D, Points3D, log
+
     recording = RecordingStream.to_native(recording)
 
     if keypoint_id is not None and class_id is None:
         class_id = 0
     if position is not None:
         position = np.require(position, dtype="float32")
-
-    instanced: dict[str, Any] = {}
-    splats: dict[str, Any] = {}
+    else:
+        raise ValueError("`position` argument must be set")
 
     if position is not None:
         if position.size == 2:
-            instanced["rerun.point2d"] = Point2DArray.from_numpy(position.reshape(1, 2))
+            points2d = Points2D(
+                points=position,
+                radii=radius,
+                colors=color,
+                labels=label,
+                draw_order=draw_order,
+                class_ids=class_id,
+                keypoint_ids=keypoint_id,
+            )
+            return log(entity_path, points2d, ext=ext, timeless=timeless, recording=recording)
         elif position.size == 3:
-            instanced["rerun.point3d"] = Point3DArray.from_numpy(position.reshape(1, 3))
+            points3d = Points3D(
+                points=position,
+                radii=radius,
+                colors=color,
+                labels=label,
+                draw_order=draw_order,
+                class_ids=class_id,
+                keypoint_ids=keypoint_id,
+            )
+            return log(entity_path, points3d, ext=ext, timeless=timeless, recording=recording)
         else:
             raise TypeError("Position must have a total size of 2 or 3")
 
-    if color is not None:
-        colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
-
-    if radius:
-        radii = _normalize_radii([radius])
-        instanced["rerun.radius"] = RadiusArray.from_numpy(radii)
-
-    if label:
-        instanced["rerun.label"] = LabelArray.new([label])
-
-    if class_id:
-        class_ids = _normalize_ids([class_id])
-        instanced["rerun.class_id"] = ClassIdArray.from_numpy(class_ids)
-
-    if draw_order is not None:
-        instanced["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
-
-    if ext:
-        _add_extension_components(instanced, splats, ext, None)
-
-    if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
-        bindings.log_arrow_msg(entity_path, components=splats, timeless=timeless, recording=recording)
-
-    # Always the primary component last so range-based queries will include the other data. See(#1215)
-    if instanced:
-        bindings.log_arrow_msg(entity_path, components=instanced, timeless=timeless, recording=recording)
-
 
 @log_decorator
 def log_points(
     entity_path: str,
-    positions: npt.ArrayLike | None = None,
+    positions: npt.ArrayLike,
     *,
     identifiers: npt.ArrayLike | None = None,
     colors: Color | Colors | None = None,
@@ -218,21 +195,17 @@ def log_points(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import Points2D, Points3D, log
+
     recording = RecordingStream.to_native(recording)
 
     if keypoint_ids is not None and class_ids is None:
         class_ids = 0
     if positions is None:
-        positions = np.require([], dtype="float32")
+        raise ValueError("`positions` argument must be set")
     else:
         positions = np.require(positions, dtype="float32")
 
-    colors = _normalize_colors(colors)
-    radii = _normalize_radii(radii)
-    labels = _normalize_labels(labels)
-    class_ids = _normalize_ids(class_ids)
-    keypoint_ids = _normalize_ids(keypoint_ids)
-
     identifiers_np = np.array((), dtype="uint64")
     if identifiers is not None:
         try:
@@ -240,51 +213,30 @@ def log_points(
         except ValueError:
             _send_warning("Only integer identifiers supported", 1)
 
-    # 0 = instanced, 1 = splat
-    comps = [{}, {}]  # type: ignore[var-annotated]
-
     if positions.any():
         if positions.shape[1] == 2:
-            comps[0]["rerun.point2d"] = Point2DArray.from_numpy(positions)
+            points2d = Points2D(
+                points=positions,
+                radii=radii,
+                colors=colors,
+                labels=labels,
+                draw_order=draw_order,
+                class_ids=class_ids,
+                keypoint_ids=keypoint_ids,
+                instance_keys=identifiers_np,
+            )
+            return log(entity_path, points2d, ext=ext, timeless=timeless, recording=recording)
         elif positions.shape[1] == 3:
-            comps[0]["rerun.point3d"] = Point3DArray.from_numpy(positions)
+            points3d = Points3D(
+                points=positions,
+                radii=radii,
+                colors=colors,
+                labels=labels,
+                draw_order=draw_order,
+                class_ids=class_ids,
+                keypoint_ids=keypoint_ids,
+                instance_keys=identifiers_np,
+            )
+            return log(entity_path, points3d, ext=ext, timeless=timeless, recording=recording)
         else:
-            raise TypeError("Positions should be either Nx2 or Nx3")
-
-    if len(identifiers_np):
-        comps[0]["rerun.instance_key"] = InstanceArray.from_numpy(identifiers_np)
-
-    if len(colors):
-        is_splat = len(colors.shape) == 1
-        if is_splat:
-            colors = colors.reshape(1, len(colors))
-        comps[is_splat]["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
-
-    if len(radii):
-        is_splat = len(radii) == 1
-        comps[is_splat]["rerun.radius"] = RadiusArray.from_numpy(radii)
-
-    if len(labels):
-        is_splat = len(labels) == 1
-        comps[is_splat]["rerun.label"] = LabelArray.new(labels)
-
-    if len(class_ids):
-        is_splat = len(class_ids) == 1
-        comps[is_splat]["rerun.class_id"] = ClassIdArray.from_numpy(class_ids)
-
-    if len(keypoint_ids):
-        is_splat = len(keypoint_ids) == 1
-        comps[is_splat]["rerun.keypoint_id"] = ClassIdArray.from_numpy(keypoint_ids)
-
-    if draw_order is not None:
-        comps[True]["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
-
-    if ext:
-        _add_extension_components(comps[0], comps[1], ext, identifiers_np)
-
-    if comps[1]:
-        comps[1]["rerun.instance_key"] = InstanceArray.splat()
-        bindings.log_arrow_msg(entity_path, components=comps[1], timeless=timeless, recording=recording)
-
-    # Always the primary component last so range-based queries will include the other data. See(#1215)
-    bindings.log_arrow_msg(entity_path, components=comps[0], timeless=timeless, recording=recording)
+            raise TypeError("Positions should be Nx2 or Nx3")
diff --git a/rerun_py/rerun_sdk/rerun/log/rects.py b/rerun_py/rerun_sdk/rerun/log/rects.py
index e18c54f8c9a9..52082e5fc30d 100644
--- a/rerun_py/rerun_sdk/rerun/log/rects.py
+++ b/rerun_py/rerun_sdk/rerun/log/rects.py
@@ -6,11 +6,8 @@
 import numpy.typing as npt
 
 from rerun import bindings
-from rerun.components.annotation import ClassIdArray
-from rerun.components.color import ColorRGBAArray
+from rerun.components import splat
 from rerun.components.draw_order import DrawOrderArray
-from rerun.components.instance import InstanceArray
-from rerun.components.label import LabelArray
 from rerun.components.rect2d import Rect2DArray, RectFormat
 from rerun.log import Color, Colors, OptionalClassIds, _normalize_colors, _normalize_ids, _normalize_labels
 from rerun.log.error_utils import _send_warning
@@ -72,6 +69,8 @@ def log_rect(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     if np.any(rect):  # type: ignore[arg-type]
@@ -87,14 +86,14 @@ def log_rect(
 
     if color is not None:
         colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        instanced["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     if label:
-        instanced["rerun.label"] = LabelArray.new([label])
+        instanced["rerun.label"] = rrc.LabelArray.from_similar([label])
 
     if class_id:
         class_ids = _normalize_ids([class_id])
-        instanced["rerun.class_id"] = ClassIdArray.from_numpy(class_ids)
+        instanced["rerun.class_id"] = rrc.ClassIdArray.from_similar(class_ids)
 
     if draw_order is not None:
         instanced["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
@@ -103,7 +102,7 @@ def log_rect(
         _add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(
             entity_path,
             components=splats,
@@ -183,6 +182,8 @@ def log_rects(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     # Treat None the same as []
@@ -209,21 +210,23 @@ def log_rects(
     comps[0]["rerun.rect2d"] = Rect2DArray.from_numpy_and_format(rects, rect_format)
 
     if len(identifiers_np):
-        comps[0]["rerun.instance_key"] = InstanceArray.from_numpy(identifiers_np)
+        comps[0]["rerun.instance_key"] = rrc.InstanceKeyArray.from_similar(identifiers_np)
 
     if len(colors):
+        from rerun.experimental import cmp as rrc
+
         is_splat = len(colors.shape) == 1
         if is_splat:
             colors = colors.reshape(1, len(colors))
-        comps[is_splat]["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        comps[is_splat]["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     if len(labels):
         is_splat = len(labels) == 1
-        comps[is_splat]["rerun.label"] = LabelArray.new(labels)
+        comps[is_splat]["rerun.label"] = rrc.LabelArray.from_similar(labels)
 
     if len(class_ids):
         is_splat = len(class_ids) == 1
-        comps[is_splat]["rerun.class_id"] = ClassIdArray.from_numpy(class_ids)
+        comps[is_splat]["rerun.class_id"] = rrc.ClassIdArray.from_similar(class_ids)
 
     if draw_order is not None:
         comps[True]["rerun.draw_order"] = DrawOrderArray.splat(draw_order)
@@ -232,7 +235,7 @@ def log_rects(
         _add_extension_components(comps[0], comps[1], ext, identifiers_np)
 
     if comps[1]:
-        comps[1]["rerun.instance_key"] = InstanceArray.splat()
+        comps[1]["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(
             entity_path,
             components=comps[1],
diff --git a/rerun_py/rerun_sdk/rerun/log/scalar.py b/rerun_py/rerun_sdk/rerun/log/scalar.py
index c58f0ea7d05c..9fbb0b868f69 100644
--- a/rerun_py/rerun_sdk/rerun/log/scalar.py
+++ b/rerun_py/rerun_sdk/rerun/log/scalar.py
@@ -5,10 +5,7 @@
 import numpy as np
 
 from rerun import bindings
-from rerun.components.color import ColorRGBAArray
-from rerun.components.instance import InstanceArray
-from rerun.components.label import LabelArray
-from rerun.components.radius import RadiusArray
+from rerun.components import splat
 from rerun.components.scalar import ScalarArray, ScalarPlotPropsArray
 from rerun.log import Color, _normalize_colors
 from rerun.log.extension_components import _add_extension_components
@@ -120,6 +117,8 @@ def log_scalar(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     instanced: dict[str, Any] = {}
@@ -128,14 +127,16 @@ def log_scalar(
     instanced["rerun.scalar"] = ScalarArray.from_numpy(np.array([scalar]))
 
     if label:
-        instanced["rerun.label"] = LabelArray.new([label])
+        instanced["rerun.label"] = rrc.LabelArray.from_similar([label])
 
     if color is not None:
+        from rerun.experimental import cmp as rrc
+
         colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        instanced["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     if radius:
-        instanced["rerun.radius"] = RadiusArray.from_numpy(np.array([radius]))
+        instanced["rerun.radius"] = rrc.RadiusArray.from_similar(np.array([radius]))
 
     if scattered:
         props = [{"scattered": scattered}]
@@ -145,7 +146,7 @@ def log_scalar(
         _add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=splats, timeless=False, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
diff --git a/rerun_py/rerun_sdk/rerun/log/tensor.py b/rerun_py/rerun_sdk/rerun/log/tensor.py
index 9ea4087d8b11..83e2ec8484a5 100644
--- a/rerun_py/rerun_sdk/rerun/log/tensor.py
+++ b/rerun_py/rerun_sdk/rerun/log/tensor.py
@@ -6,8 +6,8 @@
 import numpy.typing as npt
 
 from rerun import bindings
+from rerun.components import splat
 from rerun.components.draw_order import DrawOrderArray
-from rerun.components.instance import InstanceArray
 from rerun.components.tensor import TensorArray
 from rerun.log.error_utils import _send_warning
 from rerun.log.extension_components import _add_extension_components
@@ -148,7 +148,7 @@ def _log_tensor(
         _add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(
             entity_path,
             components=splats,
diff --git a/rerun_py/rerun_sdk/rerun/log/text.py b/rerun_py/rerun_sdk/rerun/log/text.py
index 5088b2c664eb..6dfa733bc240 100644
--- a/rerun_py/rerun_sdk/rerun/log/text.py
+++ b/rerun_py/rerun_sdk/rerun/log/text.py
@@ -5,8 +5,7 @@
 
 import rerun.log.extension_components
 from rerun import bindings
-from rerun.components.color import ColorRGBAArray
-from rerun.components.instance import InstanceArray
+from rerun.components import splat
 from rerun.components.text_entry import TextEntryArray
 from rerun.log import Color, _normalize_colors
 from rerun.log.log_decorator import log_decorator
@@ -106,6 +105,7 @@ def log_text_entry(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
 
     recording = RecordingStream.to_native(recording)
 
@@ -119,13 +119,13 @@ def log_text_entry(
 
     if color is not None:
         colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        instanced["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     if ext:
         rerun.log.extension_components._add_extension_components(instanced, splats, ext, None)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=splats, timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
diff --git a/rerun_py/rerun_sdk/rerun/log/text_internal.py b/rerun_py/rerun_sdk/rerun/log/text_internal.py
index b455bb71c118..0efd5ef09412 100644
--- a/rerun_py/rerun_sdk/rerun/log/text_internal.py
+++ b/rerun_py/rerun_sdk/rerun/log/text_internal.py
@@ -5,8 +5,7 @@
 from typing import Any, Final
 
 from rerun import bindings
-from rerun.components.color import ColorRGBAArray
-from rerun.components.instance import InstanceArray
+from rerun.components import splat
 from rerun.components.text_entry import TextEntryArray
 from rerun.log import Color, _normalize_colors
 from rerun.recording_stream import RecordingStream
@@ -82,6 +81,8 @@ def log_text_entry_internal(
         See also: [`rerun.init`][], [`rerun.set_global_data_recording`][].
 
     """
+    from rerun.experimental import cmp as rrc
+
     recording = RecordingStream.to_native(recording)
 
     instanced: dict[str, Any] = {}
@@ -94,10 +95,10 @@ def log_text_entry_internal(
 
     if color is not None:
         colors = _normalize_colors(color)
-        instanced["rerun.colorrgba"] = ColorRGBAArray.from_numpy(colors)
+        instanced["rerun.colorrgba"] = rrc.ColorArray.from_similar(colors)
 
     if splats:
-        splats["rerun.instance_key"] = InstanceArray.splat()
+        splats["rerun.instance_key"] = splat()
         bindings.log_arrow_msg(entity_path, components=splats, timeless=timeless, recording=recording)
 
     # Always the primary component last so range-based queries will include the other data. See(#1215)
diff --git a/rerun_py/src/python_bridge.rs b/rerun_py/src/python_bridge.rs
index 67b6d7753752..72b6daa1f0de 100644
--- a/rerun_py/src/python_bridge.rs
+++ b/rerun_py/src/python_bridge.rs
@@ -28,7 +28,7 @@ use rerun::{
 
 pub use rerun::{
     components::{
-        AnnotationContext, AnnotationInfo, Arrow3D, Box3D, ClassDescription, ClassId, ColorRGBA,
+        AnnotationContext, AnnotationInfo, Arrow3D, Box3D, ClassDescription, ClassId, Color,
         DisconnectedSpace, DrawOrder, EncodedMesh3D, InstanceKey, KeypointId, Label, LineStrip2D,
         LineStrip3D, Mat3x3, Mesh3D, MeshFormat, MeshId, Pinhole, Point2D, Point3D, Quaternion,
         Radius, RawMesh3D, Rect2D, Scalar, ScalarPlotProps, Tensor, TensorData, TensorDimension,
@@ -769,7 +769,7 @@ impl From<AnnotationInfoTuple> for AnnotationInfo {
         let AnnotationInfoTuple(id, label, color) = tuple;
         Self {
             id,
-            label: label.map(Label),
+            label: label.map(Into::into),
             color: color
                 .as_ref()
                 .map(|color| convert_color(color.clone()).unwrap())
@@ -900,13 +900,13 @@ fn log_meshes(
                 [_, 3] => Some(
                     slice_from_np_array(&vertex_colors)
                         .chunks_exact(3)
-                        .map(|c| ColorRGBA::from_rgb(c[0], c[1], c[2]).0)
+                        .map(|c| Color::from_rgb(c[0], c[1], c[2]).0)
                         .collect(),
                 ),
                 [_, 4] => Some(
                     slice_from_np_array(&vertex_colors)
                         .chunks_exact(4)
-                        .map(|c| ColorRGBA::from_unmultiplied_rgba(c[0], c[1], c[2], c[3]).0)
+                        .map(|c| Color::from_unmultiplied_rgba(c[0], c[1], c[2], c[3]).0)
                         .collect(),
                 ),
                 shape => {
diff --git a/tests/rust/roundtrips/points2d/src/main.rs b/tests/rust/roundtrips/points2d/src/main.rs
index d9eb15624442..58fbd1d2e59b 100644
--- a/tests/rust/roundtrips/points2d/src/main.rs
+++ b/tests/rust/roundtrips/points2d/src/main.rs
@@ -1,8 +1,7 @@
 //! Logs a `Points2D` archetype for roundtrip checks.
 
 use rerun::{
-    components::Rect2D, experimental::archetypes::Points2D, external::re_log, MsgSender,
-    RecordingStream,
+    archetypes::Points2D, components::Rect2D, external::re_log, MsgSender, RecordingStream,
 };
 
 #[derive(Debug, clap::Parser)]
diff --git a/tests/rust/roundtrips/points3d/src/main.rs b/tests/rust/roundtrips/points3d/src/main.rs
index 2d46cf01706a..4d2a3799714e 100644
--- a/tests/rust/roundtrips/points3d/src/main.rs
+++ b/tests/rust/roundtrips/points3d/src/main.rs
@@ -1,6 +1,6 @@
 //! Logs a `Points3D` archetype for roundtrip checks.
 
-use rerun::{experimental::archetypes::Points3D, external::re_log, MsgSender, RecordingStream};
+use rerun::{archetypes::Points3D, external::re_log, MsgSender, RecordingStream};
 
 #[derive(Debug, clap::Parser)]
 #[clap(author, version, about)]
diff --git a/tests/rust/roundtrips/transform3d/src/main.rs b/tests/rust/roundtrips/transform3d/src/main.rs
index 53cad92a63aa..b21600fa024b 100644
--- a/tests/rust/roundtrips/transform3d/src/main.rs
+++ b/tests/rust/roundtrips/transform3d/src/main.rs
@@ -2,11 +2,15 @@
 
 use std::f32::consts::PI;
 
-use rerun::experimental::datatypes::{
-    Angle, RotationAxisAngle, Scale3D, TranslationAndMat3x3, TranslationRotationScale3D,
+use rerun::{
+    archetypes::Transform3D,
+    datatypes,
+    datatypes::{
+        Angle, RotationAxisAngle, Scale3D, TranslationAndMat3x3, TranslationRotationScale3D,
+    },
+    external::re_log,
+    MsgSender, RecordingStream,
 };
-use rerun::experimental::{archetypes::Transform3D, datatypes};
-use rerun::{external::re_log, MsgSender, RecordingStream};
 
 #[derive(Debug, clap::Parser)]
 #[clap(author, version, about)]
diff --git a/tests/rust/test_api/src/main.rs b/tests/rust/test_api/src/main.rs
index 5380c8e1a57d..5b4f36520618 100644
--- a/tests/rust/test_api/src/main.rs
+++ b/tests/rust/test_api/src/main.rs
@@ -17,7 +17,7 @@ use std::{collections::HashSet, f32::consts::TAU};
 use itertools::Itertools;
 use rerun::{
     components::{
-        AnnotationContext, AnnotationInfo, Box3D, ClassDescription, ClassId, ColorRGBA, DrawOrder,
+        AnnotationContext, AnnotationInfo, Box3D, ClassDescription, ClassId, Color, DrawOrder,
         Label, LineStrip2D, LineStrip3D, Point2D, Point3D, Radius, Rect2D, Tensor,
         TensorDataMeaning, TextEntry, Vec2D, Vec3D, ViewCoordinates,
     },
@@ -36,36 +36,32 @@ fn test_bbox(rec_stream: &RecordingStream) -> anyhow::Result<()> {
     rec_stream.set_time_seconds("sim_time", 0f64);
     MsgSender::new("bbox_test/bbox")
         .with_component(&[Box3D::new(1.0, 0.5, 0.25)])?
-        .with_component(&[ColorRGBA::from_rgb(0, 255, 0)])?
+        .with_component(&[Color::from_rgb(0, 255, 0)])?
         .with_component(&[Radius(0.005)])?
         .with_component(&[Label("box/t0".to_owned())])?
         .send(rec_stream)?;
     MsgSender::from_archetype(
         "bbox_test/bbox",
-        &rerun::experimental::archetypes::Transform3D::new(
-            rerun::experimental::datatypes::RotationAxisAngle::new(
-                glam::Vec3::Z,
-                rerun::experimental::datatypes::Angle::Degrees(180.0),
-            ),
-        ),
+        &rerun::archetypes::Transform3D::new(rerun::datatypes::RotationAxisAngle::new(
+            glam::Vec3::Z,
+            rerun::datatypes::Angle::Degrees(180.0),
+        )),
     )?
     .send(rec_stream)?;
 
     rec_stream.set_time_seconds("sim_time", 1f64);
     MsgSender::new("bbox_test/bbox")
         .with_component(&[Box3D::new(1.0, 0.5, 0.25)])?
-        .with_component(&[ColorRGBA::from_rgb(255, 255, 0)])?
+        .with_component(&[Color::from_rgb(255, 255, 0)])?
         .with_component(&[Radius(0.01)])?
         .with_component(&[Label("box/t1".to_owned())])?
         .send(rec_stream)?;
     MsgSender::from_archetype(
         "bbox_test/bbox",
-        &rerun::experimental::archetypes::Transform3D::new(
-            rerun::experimental::datatypes::RotationAxisAngle::new(
-                [1.0, 0.0, 0.0],
-                rerun::experimental::datatypes::Angle::Degrees(180.0),
-            ),
-        ),
+        &rerun::archetypes::Transform3D::new(rerun::datatypes::RotationAxisAngle::new(
+            [1.0, 0.0, 0.0],
+            rerun::datatypes::Angle::Degrees(180.0),
+        )),
     )?
     .send(rec_stream)?;
 
@@ -104,7 +100,7 @@ fn test_extension_components(rec_stream: &RecordingStream) -> anyhow::Result<()>
     rec_stream.set_time_seconds("sim_time", 0f64);
     MsgSender::new("extension_components/point")
         .with_component(&[Point2D::new(64.0, 64.0)])?
-        .with_component(&[ColorRGBA::from_rgb(255, 0, 0)])?
+        .with_component(&[Color::from_rgb(255, 0, 0)])?
         .with_component(&[Confidence(0.9)])?
         .send(rec_stream)?;
 
@@ -153,7 +149,7 @@ fn test_extension_components(rec_stream: &RecordingStream) -> anyhow::Result<()>
             Point2D::new(96.0, 32.0),
             Point2D::new(96.0, 96.0),
         ])?
-        .with_splat(ColorRGBA::from_rgb(0, 255, 0))?
+        .with_splat(Color::from_rgb(0, 255, 0))?
         .with_component(&[
             Corner("upper left".into()),
             Corner("lower left".into()),
@@ -176,12 +172,12 @@ fn test_log_cleared(rec_stream: &RecordingStream) -> anyhow::Result<()> {
     rec_stream.set_time_seconds("sim_time", 1f64);
     MsgSender::new("null_test/rect/0")
         .with_component(&[Rect2D::from_xywh(5.0, 5.0, 4.0, 4.0)])?
-        .with_component(&[ColorRGBA::from_rgb(255, 0, 0)])?
+        .with_component(&[Color::from_rgb(255, 0, 0)])?
         .with_component(&[Label("Rect1".into())])?
         .send(rec_stream)?;
     MsgSender::new("null_test/rect/1")
         .with_component(&[Rect2D::from_xywh(10.0, 5.0, 4.0, 4.0)])?
-        .with_component(&[ColorRGBA::from_rgb(0, 255, 0)])?
+        .with_component(&[Color::from_rgb(0, 255, 0)])?
         .with_component(&[Label("Rect2".into())])?
         .send(rec_stream)?;
 
@@ -221,7 +217,7 @@ fn test_3d_points(rec_stream: &RecordingStream) -> anyhow::Result<()> {
         x: impl Fn(f32) -> f32,
         y: impl Fn(f32) -> f32,
         z: impl Fn(f32) -> f32,
-    ) -> (Vec<Label>, Vec<Point3D>, Vec<Radius>, Vec<ColorRGBA>) {
+    ) -> (Vec<Label>, Vec<Point3D>, Vec<Radius>, Vec<Color>) {
         use rand::Rng as _;
         let mut rng = rand::thread_rng();
         itertools::multiunzip((0..n).map(|i| {
@@ -231,7 +227,7 @@ fn test_3d_points(rec_stream: &RecordingStream) -> anyhow::Result<()> {
                 Label(i.to_string()),
                 Point3D::new(x((i * 0.2).sin()), y((i * 0.2).cos()), z(i)),
                 Radius(t * 0.1 + (1.0 - t) * 2.0), // lerp(0.1, 2.0, t)
-                ColorRGBA::from_rgb(rng.gen(), rng.gen(), rng.gen()),
+                Color::from_rgb(rng.gen(), rng.gen(), rng.gen()),
             )
         }))
     }
@@ -276,7 +272,7 @@ fn test_rects(rec_stream: &RecordingStream) -> anyhow::Result<()> {
         .collect::<Vec<_>>();
     let colors = Array::random((20, 3), Uniform::new(0, 255))
         .axis_iter(Axis(0))
-        .map(|c| ColorRGBA::from_rgb(c[0], c[1], c[2]))
+        .map(|c| Color::from_rgb(c[0], c[1], c[2]))
         .collect::<Vec<_>>();
 
     rec_stream.set_time_seconds("sim_time", 2f64);
@@ -357,7 +353,7 @@ fn test_2d_layering(rec_stream: &RecordingStream) -> anyhow::Result<()> {
         .send(rec_stream)?;
 
     // And some points in front of the rectangle.
-    use rerun::experimental::archetypes::Points2D;
+    use rerun::archetypes::Points2D;
     MsgSender::from_archetype(
         "2d_layering/points_between_top_and_middle",
         &Points2D::new(
@@ -399,7 +395,7 @@ fn test_segmentation(rec_stream: &RecordingStream) -> anyhow::Result<()> {
         .send(rec_stream)?;
 
     // Log a bunch of classified 2D points
-    use rerun::experimental::archetypes::Points2D;
+    use rerun::archetypes::Points2D;
     MsgSender::from_archetype(
         "seg_test/single_point",
         &Points2D::new([(64.0, 64.0)]).with_class_ids([13]),
@@ -450,8 +446,8 @@ fn test_segmentation(rec_stream: &RecordingStream) -> anyhow::Result<()> {
             ClassDescription {
                 info: AnnotationInfo {
                     id,
-                    label: label.map(|label| Label(label.into())),
-                    color: color.map(|c| ColorRGBA::from_rgb(c[0], c[1], c[2])),
+                    label: label.map(Into::into),
+                    color: color.map(|c| Color::from_rgb(c[0], c[1], c[2]).into()),
                 },
                 ..Default::default()
             },
@@ -520,7 +516,7 @@ fn test_text_logs(rec_stream: &RecordingStream) -> anyhow::Result<()> {
 
     MsgSender::new("logs")
         .with_component(&[TextEntry::new("Text with explicitly set color", None)])?
-        .with_component(&[ColorRGBA::from_rgb(255, 215, 0)])?
+        .with_component(&[Color::from_rgb(255, 215, 0)])?
         .send(rec_stream)?;
 
     MsgSender::new("logs")
@@ -551,7 +547,7 @@ fn test_transforms_3d(rec_stream: &RecordingStream) -> anyhow::Result<()> {
         MsgSender::new(ent_path.into())
             .with_timeless(true)
             .with_component(&[view_coords])?
-            .with_component(&[ColorRGBA::from_rgb(255, 215, 0)])?
+            .with_component(&[Color::from_rgb(255, 215, 0)])?
             .send(rec_stream)
             .map_err(Into::into)
     }
@@ -572,7 +568,7 @@ fn test_transforms_3d(rec_stream: &RecordingStream) -> anyhow::Result<()> {
         MsgSender::new(ent_path.into())
             .with_component(&[Point3D::ZERO])?
             .with_component(&[Radius(radius)])?
-            .with_component(&[ColorRGBA::from_rgb(color[0], color[1], color[2])])?
+            .with_component(&[Color::from_rgb(color[0], color[1], color[2])])?
             .send(rec_stream)
             .map_err(Into::into)
     }
@@ -604,7 +600,7 @@ fn test_transforms_3d(rec_stream: &RecordingStream) -> anyhow::Result<()> {
     MsgSender::new("transforms3d/sun/planet/dust")
         .with_component(&points)?
         .with_splat(Radius(0.025))?
-        .with_splat(ColorRGBA::from_rgb(80, 80, 80))?
+        .with_splat(Color::from_rgb(80, 80, 80))?
         .send(rec_stream)?;
 
     // paths where the planet & moon move
@@ -632,16 +628,16 @@ fn test_transforms_3d(rec_stream: &RecordingStream) -> anyhow::Result<()> {
 
         MsgSender::from_archetype(
             "transforms3d/sun/planet",
-            &rerun::experimental::archetypes::Transform3D::new(
-                rerun::experimental::datatypes::TranslationRotationScale3D::rigid(
+            &rerun::archetypes::Transform3D::new(
+                rerun::datatypes::TranslationRotationScale3D::rigid(
                     [
                         (time * rotation_speed_planet).sin() * sun_to_planet_distance,
                         (time * rotation_speed_planet).cos() * sun_to_planet_distance,
                         0.0,
                     ],
-                    rerun::experimental::datatypes::RotationAxisAngle::new(
+                    rerun::datatypes::RotationAxisAngle::new(
                         glam::Vec3::X,
-                        rerun::experimental::datatypes::Angle::Degrees(20.0),
+                        rerun::datatypes::Angle::Degrees(20.0),
                     ),
                 ),
             ),
@@ -650,14 +646,12 @@ fn test_transforms_3d(rec_stream: &RecordingStream) -> anyhow::Result<()> {
 
         MsgSender::from_archetype(
             "transforms3d/sun/planet/moon",
-            &rerun::experimental::archetypes::Transform3D::new(
-                rerun::experimental::datatypes::TranslationRotationScale3D::from(
-                    rerun::experimental::datatypes::Vec3D::new(
-                        (time * rotation_speed_moon).cos() * planet_to_moon_distance,
-                        (time * rotation_speed_moon).sin() * planet_to_moon_distance,
-                        0.0,
-                    ),
-                )
+            &rerun::archetypes::Transform3D::new(
+                rerun::datatypes::TranslationRotationScale3D::from(rerun::datatypes::Vec3D::new(
+                    (time * rotation_speed_moon).cos() * planet_to_moon_distance,
+                    (time * rotation_speed_moon).sin() * planet_to_moon_distance,
+                    0.0,
+                ))
                 .from_parent(),
             ),
         )?