diff --git a/assets/locales/pending/properties-moment-of-inertia.json b/assets/locales/pending/properties-moment-of-inertia.json
new file mode 100644
index 0000000000..9294106192
--- /dev/null
+++ b/assets/locales/pending/properties-moment-of-inertia.json
@@ -0,0 +1,117 @@
+{
+  "en": {
+    "ui.properties.copy_matrix": "Copy matrix",
+    "ui.properties.first_moments": "First moments",
+    "ui.properties.inertia": "Moment of inertia",
+    "ui.properties.inertia_note": "About the center of mass, in world axes (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "Not available: a body's mesh does not close.",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "Measuring…",
+    "ui.properties.measuring_failed": "Measuring stopped before it finished.",
+    "ui.properties.principal_axis": "Principal axis {number}",
+    "ui.properties.principal_moments": "Principal moments"
+  },
+  "en-GB": {
+    "ui.properties.inertia_note": "About the centre of mass, in world axes (g·{unit}²)"
+  },
+  "ar": {
+    "ui.properties.copy_matrix": "نسخ المصفوفة",
+    "ui.properties.first_moments": "العزوم الأولى",
+    "ui.properties.inertia": "عزم القصور الذاتي",
+    "ui.properties.inertia_note": "حول مركز الكتلة، بمحاور العالم (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "غير متاح: شبكة أحد الأجسام غير مغلقة.",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "جارٍ القياس…",
+    "ui.properties.measuring_failed": "توقف القياس قبل أن يكتمل.",
+    "ui.properties.principal_axis": "المحور الرئيسي {number}",
+    "ui.properties.principal_moments": "العزوم الرئيسية"
+  },
+  "de": {
+    "ui.properties.copy_matrix": "Matrix kopieren",
+    "ui.properties.first_moments": "Statische Momente",
+    "ui.properties.inertia": "Trägheitsmoment",
+    "ui.properties.inertia_note": "Um den Massenschwerpunkt, in Weltachsen (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "Nicht verfügbar: Das Netz eines Körpers ist nicht geschlossen.",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "Wird gemessen…",
+    "ui.properties.measuring_failed": "Die Messung wurde vor dem Ende abgebrochen.",
+    "ui.properties.principal_axis": "Hauptachse {number}",
+    "ui.properties.principal_moments": "Hauptträgheitsmomente"
+  },
+  "he": {
+    "ui.properties.copy_matrix": "העתקת המטריצה",
+    "ui.properties.first_moments": "מומנטים ראשונים",
+    "ui.properties.inertia": "מומנט התמד",
+    "ui.properties.inertia_note": "סביב מרכז מסה, בצירי העולם (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "לא זמין: הרשת של אחד הגופים אינה סגורה.",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "מודד…",
+    "ui.properties.measuring_failed": "המדידה נעצרה לפני שהסתיימה.",
+    "ui.properties.principal_axis": "ציר ראשי {number}",
+    "ui.properties.principal_moments": "מומנטים ראשיים"
+  },
+  "ja": {
+    "ui.properties.copy_matrix": "行列をコピー",
+    "ui.properties.first_moments": "一次モーメント",
+    "ui.properties.inertia": "慣性モーメント",
+    "ui.properties.inertia_note": "重心まわり、ワールド軸 (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "利用できません: ボディのメッシュが閉じていません。",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "測定中…",
+    "ui.properties.measuring_failed": "測定が完了する前に停止しました。",
+    "ui.properties.principal_axis": "主軸 {number}",
+    "ui.properties.principal_moments": "主慣性モーメント"
+  },
+  "ko": {
+    "ui.properties.copy_matrix": "행렬 복사",
+    "ui.properties.first_moments": "1차 모멘트",
+    "ui.properties.inertia": "관성 모멘트",
+    "ui.properties.inertia_note": "질량 중심 기준, 월드 축 (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "사용할 수 없음: 바디의 메시가 닫혀 있지 않습니다.",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "측정 중…",
+    "ui.properties.measuring_failed": "측정이 끝나기 전에 중단되었습니다.",
+    "ui.properties.principal_axis": "주축 {number}",
+    "ui.properties.principal_moments": "주관성 모멘트"
+  },
+  "vi": {
+    "ui.properties.copy_matrix": "Sao chép ma trận",
+    "ui.properties.first_moments": "Mômen bậc nhất",
+    "ui.properties.inertia": "Mômen quán tính",
+    "ui.properties.inertia_note": "Quanh trọng tâm, theo các trục thế giới (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "Không khả dụng: lưới của một thân khối không kín.",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "Đang đo…",
+    "ui.properties.measuring_failed": "Phép đo đã dừng trước khi hoàn tất.",
+    "ui.properties.principal_axis": "Trục chính {number}",
+    "ui.properties.principal_moments": "Mômen quán tính chính"
+  },
+  "zh": {
+    "ui.properties.copy_matrix": "复制矩阵",
+    "ui.properties.first_moments": "一阶矩",
+    "ui.properties.inertia": "转动惯量",
+    "ui.properties.inertia_note": "相对质心，世界坐标轴 (g·{unit}²)",
+    "ui.properties.inertia_unavailable": "不可用：某个实体的网格未闭合。",
+    "ui.properties.inertia_x": "Ixx, Ixy, Ixz",
+    "ui.properties.inertia_y": "Iyx, Iyy, Iyz",
+    "ui.properties.inertia_z": "Izx, Izy, Izz",
+    "ui.properties.measuring": "正在测量…",
+    "ui.properties.measuring_failed": "测量在完成前已停止。",
+    "ui.properties.principal_axis": "主轴 {number}",
+    "ui.properties.principal_moments": "主惯性矩"
+  }
+}
diff --git a/crates/engine/src/cmd/component.rs b/crates/engine/src/cmd/component.rs
index 0ef06e078b..04145baa81 100644
--- a/crates/engine/src/cmd/component.rs
+++ b/crates/engine/src/cmd/component.rs
@@ -78,10 +78,10 @@ pub static COMMANDS: &[CommandSpec] = &[
     ),
     CommandSpec::new("component.properties", "Component Physical Properties", properties::component)
         .icon("measure").noundo()
-        .params("component?: id or name (default active); descendants?: bool (default true). Measures the first placement, or all placements for root, including pending moves; material-aware mass and center of mass in world coordinates; volume, density, mass and center of mass only for closed, consistently oriented bodies; total.open_bodies_skipped counts open bodies excluded from volume/mass totals"),
+        .params("component?: id or name (default active); descendants?: bool (default true); about?: [x, y, z] (mm). Measures the first placement, or all placements for root, including pending moves; material-aware mass and center of mass in world coordinates; volume, density, mass, center of mass and inertia_g_mm2 (the inertia tensor about the body's center of mass, world axes, from its tessellation) only for closed, consistently oriented bodies; total.open_bodies_skipped counts open bodies excluded from volume/mass totals; total.first_moment_g_mm (mass × center of mass), inertia_g_mm2 about the total center of mass, principal_moments_g_mm2 (smallest first) and principal_axes (unit, right-handed); with about, total.inertia_about {point, inertia_g_mm2}"),
     CommandSpec::new("occurrence.properties", "Occurrence Physical Properties", properties::occurrence)
         .icon("measure").noundo()
-        .params("occurrence: id or name; path?: [occurrence ids] (required if nested under multiple instances); descendants?: bool (default true). Physical properties of this placement in world coordinates, including pending moves; volume, density, mass and center of mass only for closed, consistently oriented bodies; total.open_bodies_skipped counts open bodies excluded from volume/mass totals"),
+        .params("occurrence: id or name; path?: [occurrence ids] (required if nested under multiple instances); descendants?: bool (default true); about?: [x, y, z] (mm). Physical properties of this placement in world coordinates, including pending moves; volume, density, mass, center of mass and inertia_g_mm2 only for closed, consistently oriented bodies; total.open_bodies_skipped counts open bodies excluded from volume/mass totals; total inertia as in component.properties"),
     CommandSpec::new("component.rename", "Rename Component", rename).icon("rename").params("component, name"),
     CommandSpec::new("component.delete", "Delete Component", delete).icon("delete").params("component: deletes it, its subcomponents, occurrences and features"),
     CommandSpec::new("component.unlock", "Unlock Contents", unlock).icon("rigid_group").params(
diff --git a/crates/engine/src/cmd/component_properties.rs b/crates/engine/src/cmd/component_properties.rs
index dd8033474d..023f7b7d48 100644
--- a/crates/engine/src/cmd/component_properties.rs
+++ b/crates/engine/src/cmd/component_properties.rs
@@ -1,6 +1,9 @@
 //! Physical properties of an assembly placement, with original body material assignments.
+use std::collections::{BTreeMap, BTreeSet};
+
 use serde_json::{Value, json};
 use solidcraft_doc::{Document, Mat};
+use solidcraft_geom::inertia::{self, Tensor3};
 use solidcraft_geom::{Aabb3, Vec3};
 
 use crate::params::bad;
@@ -14,6 +17,23 @@ fn descendants(p: &Value, cmd: &str) -> Result<bool> {
     }
 }
 
+/// Principal moments this close (a share of the largest) count as equal: a round body's
+/// tessellation tells its two equal moments apart by about 1e-4, which turns their axes at random.
+const EQUAL_MOMENTS: f64 = 1e-3;
+
+/// The point `about` asks for the inertia tensor about, if any.
+fn about(p: &Value, cmd: &str) -> Result<Option<Vec3>> {
+    match p.get("about") {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => crate::params::vec3(v).map(Some).ok_or_else(|| bad(cmd, "`about` must be a point [x, y, z] in mm")),
+    }
+}
+
+/// The 3 × 3 linear part of a placement, row by row: its turn, and any scale or mirror.
+fn linear(m: &Mat) -> Tensor3 {
+    [0, 1, 2].map(|i| [0, 1, 2].map(|j| m[j][i]))
+}
+
 fn placed_doc(s: &Session) -> Document {
     let mut doc = (*s.doc).clone();
     for occurrence in &mut doc.occurrences {
@@ -58,7 +78,7 @@ pub(super) fn component(s: &mut Session, p: &Value) -> Result<Value> {
     } else {
         doc.components.iter().find(|c| c.id == id).map(|c| c.name.clone()).ok_or_else(|| bad(cmd, "no active component"))?
     };
-    let mut out = properties(s, &doc, &path, descendants(p, cmd)?, cmd)?;
+    let mut out = properties(s, &doc, &path, descendants(p, cmd)?, about(p, cmd)?, cmd)?;
     out["component"] = json!(id);
     out["name"] = json!(name);
     Ok(out)
@@ -79,13 +99,13 @@ pub(super) fn occurrence(s: &mut Session, p: &Value) -> Result<Value> {
             _ => return Err(bad(cmd, "occurrence has multiple placements; supply its `path`")),
         }
     };
-    let mut out = properties(s, &doc, &path, descendants(p, cmd)?, cmd)?;
+    let mut out = properties(s, &doc, &path, descendants(p, cmd)?, about(p, cmd)?, cmd)?;
     out["occurrence"] = json!(id);
     out["name"] = json!(doc.occurrences.iter().find(|o| o.id == id).map(|o| o.name.as_str()));
     Ok(out)
 }
 
-fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool, cmd: &str) -> Result<Value> {
+fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool, about: Option<Vec3>, cmd: &str) -> Result<Value> {
     let state = s.model.state();
     let mut bodies = Vec::new();
     let (mut volume, mut area, mut mass) = (0.0, 0.0, 0.0);
@@ -114,19 +134,40 @@ fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool,
         }
         out
     };
+    // How each closed body's volume spreads about its centre of mass (#8095): one tessellation
+    // however often it is placed, which each placement then turns.
+    let components: BTreeSet<u64> = selected_placements.iter().map(|(component, _, _)| *component).collect();
+    let spread_bodies: Vec<usize> = (0..state.bodies.len())
+        .filter(|&i| {
+            state.bodies.get(i).is_some_and(|b| components.contains(&doc.model_body_component(b)) && crate::cmd::inspect::encloses_volume(&b.body))
+        })
+        .collect();
+    let spreads = solidcraft_kernel::map_on_threads(&spread_bodies, 16, |&i| {
+        state.bodies.get(i).and_then(|b| solidcraft_io::mass_properties(&b.body).ok().flatten()).and_then(|m| m.gyration())
+    });
+    let spread: BTreeMap<usize, Tensor3> = spread_bodies.into_iter().zip(spreads).filter_map(|(i, g)| Some((i, g.flatten()?))).collect();
+    // Closed bodies' (mass, centre of mass, inertia about it), all in world axes.
+    let mut parts: Vec<(f64, Vec3, Option<Tensor3>)> = Vec::new();
     for (component, path, transform) in selected_placements {
         placement_count += 1;
-        for body in state.bodies.iter().filter(|b| doc.model_body_component(b) == component) {
+        for (index, body) in state.bodies.iter().enumerate().filter(|(_, b)| doc.model_body_component(b) == component) {
             let transform: Mat = doc.model_body_offset(body).map(|offset| solidcraft_doc::mat_mul(&transform, offset)).unwrap_or(transform);
             let placed = solidcraft_kernel::transform_matrix(&body.body, transform)?;
             let measured = solidcraft_kernel::measure(&placed)?;
             let density = doc.density(&body.name);
             let body_mass = measured.volume * density / 1000.0;
             let closed = crate::cmd::inspect::encloses_volume(&placed);
+            // The mesh's spread with the exact mass, so the tensor agrees with the mass shown.
+            let body_inertia = spread
+                .get(&index)
+                .filter(|_| closed)
+                .map(|g| inertia::from_gyration(&inertia::transformed(g, &linear(&transform)), body_mass))
+                .filter(|i| i.iter().flatten().all(|x| x.is_finite()));
             if closed {
                 volume += measured.volume;
                 mass += body_mass;
                 moment += measured.centroid * body_mass;
+                parts.push((body_mass, measured.centroid, body_inertia));
             } else {
                 skipped += 1;
             }
@@ -140,6 +181,7 @@ fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool,
                 "closed": closed, "density_g_cm3": closed.then_some(density),
                 "mass_g": closed.then_some(body_mass), "volume_mm3": closed.then_some(measured.volume),
                 "area_mm2": measured.area, "center_of_mass": closed.then_some(measured.centroid),
+                "inertia_g_mm2": body_inertia,
                 "bbox": {"min": measured.bbox.min, "max": measured.bbox.max}}));
         }
     }
@@ -150,11 +192,29 @@ fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool,
     if centroid.is_some_and(|point| !point.is_finite()) {
         return Err(bad(cmd, "center of mass exceeds supported numeric range"));
     }
+    // About the centre of mass: each body's own tensor, plus its mass at its distance from that
+    // centre (parallel axes). Unknown when any closed body's mesh did not close.
+    let at_centre = centroid.and_then(|c| {
+        parts.iter().try_fold([[0.0f64; 3]; 3], |sum, (m, at, i)| {
+            let i = inertia::shifted(&(*i)?, *m, *at - c);
+            Some([0, 1, 2].map(|r| [0, 1, 2].map(|k| sum[r][k] + i[r][k])))
+        })
+    });
+    let at_centre = at_centre.filter(|i| i.iter().flatten().all(|x| x.is_finite()));
+    let principal = at_centre.and_then(|i| inertia::principal(&i, EQUAL_MOMENTS));
     let bbox = if bodies.is_empty() { Value::Null } else { json!({"min": bounds.min, "max": bounds.max}) };
-    Ok(json!({"path": selected, "coordinate_frame": "world", "descendants": descendants,
+    let mut out = json!({"path": selected, "coordinate_frame": "world", "descendants": descendants,
         "placement_count": placement_count, "body_count": bodies.len(), "bodies": bodies,
         "total": {"open_bodies_skipped": skipped, "volume_mm3": volume, "area_mm2": area, "mass_g": mass,
-            "center_of_mass": centroid, "bbox": bbox, "faces": faces, "edges": edges, "vertices": vertices}}))
+            "center_of_mass": centroid, "first_moment_g_mm": moment, "inertia_g_mm2": at_centre,
+            "principal_moments_g_mm2": principal.map(|(moments, _)| moments), "principal_axes": principal.map(|(_, axes)| axes),
+            "bbox": bbox, "faces": faces, "edges": edges, "vertices": vertices}});
+    if let Some(point) = about {
+        let shifted =
+            centroid.zip(at_centre).map(|(c, i)| inertia::shifted(&i, mass, point - c)).filter(|i| i.iter().flatten().all(|x| x.is_finite()));
+        out["total"]["inertia_about"] = json!({"point": point, "inertia_g_mm2": shifted});
+    }
+    Ok(out)
 }
 
 #[cfg(test)]
diff --git a/crates/engine/src/cmd/component_properties_tests.rs b/crates/engine/src/cmd/component_properties_tests.rs
index e533ec37a4..f291014ea3 100644
--- a/crates/engine/src/cmd/component_properties_tests.rs
+++ b/crates/engine/src/cmd/component_properties_tests.rs
@@ -98,6 +98,114 @@ fn properties_reject_hostile_identifiers_and_options() {
     for path in [json!([]), json!(["bad"]), json!([0]), json!(vec![occurrence; 65])] {
         assert!(s.execute("occurrence.properties", &json!({"occurrence": occurrence, "path": path})).is_err());
     }
+    for about in [json!("origin"), json!([1, 2]), json!([1, 2, "z"]), json!([f64::MAX, 0, 0]), json!({"x": 1})] {
+        assert!(s.execute("component.properties", &json!({"about": about})).is_err(), "{about}");
+    }
+}
+
+fn tensor(v: &Value) -> [[f64; 3]; 3] {
+    [0, 1, 2].map(|r| [0, 1, 2].map(|c| v[r][c].as_f64().unwrap_or_else(|| panic!("no [{r}][{c}] in {v}"))))
+}
+
+fn tensor_close(actual: &Value, want: [[f64; 3]; 3], rel: f64) {
+    let got = tensor(actual);
+    let scale = want.iter().flatten().fold(0.0f64, |m, x| m.max(x.abs()));
+    for (g, w) in got.iter().flatten().zip(want.iter().flatten()) {
+        assert!((g - w).abs() <= rel * scale, "{got:?} != {want:?}");
+    }
+}
+
+/// #8095: a 10 × 20 × 30 mm steel box's inertia tensor about its centre of mass is
+/// m (b² + c²) / 12 … on the diagonal, its principal axes are its edges, and turning its
+/// placement turns the tensor with it.
+#[test]
+fn box_inertia_matches_the_closed_form_and_turns_with_its_placement() {
+    let mut s = Session::default();
+    let c = run(&mut s, "component.create", json!({"name": "Block", "grounded": false}));
+    run(&mut s, "solid.box", json!({"length": 10, "width": 20, "height": 30, "body_name": "Block"}));
+    run(&mut s, "material.assign", json!({"bodies": ["Block"], "material": "Steel"}));
+    let r = run(&mut s, "component.properties", json!({"component": c["component"]}));
+    let total = &r["total"];
+    close(&total["bbox"]["max"][1], 20.0);
+    let m = total["mass_g"].as_f64().unwrap();
+    close(&total["mass_g"], 6000.0 * s.doc.density("Block") / 1000.0);
+    let (a, b, h) = (10.0, 20.0, 30.0);
+    let (ixx, iyy, izz) = (m * (b * b + h * h) / 12.0, m * (a * a + h * h) / 12.0, m * (a * a + b * b) / 12.0);
+    tensor_close(&total["inertia_g_mm2"], [[ixx, 0.0, 0.0], [0.0, iyy, 0.0], [0.0, 0.0, izz]], 1e-9);
+    tensor_close(&r["bodies"][0]["inertia_g_mm2"], [[ixx, 0.0, 0.0], [0.0, iyy, 0.0], [0.0, 0.0, izz]], 1e-9);
+    // Smallest first: about the longest edge (z), largest about the shortest (x).
+    for (k, want) in [izz, iyy, ixx].into_iter().enumerate() {
+        assert!((total["principal_moments_g_mm2"][k].as_f64().unwrap() - want).abs() < 1e-9 * ixx, "{total}");
+    }
+    // Right-handed: z × y is −x.
+    assert_eq!(total["principal_axes"], json!([[0.0, 0.0, 1.0], [0.0, 1.0, 0.0], [-1.0, 0.0, 0.0]]));
+    for (k, want) in [5.0, 10.0, 15.0].iter().enumerate() {
+        close(&total["first_moment_g_mm"][k], m * want);
+    }
+    // A quarter turn about z swaps the x and y moments; the principal moments stay.
+    run(&mut s, "occurrence.move", json!({"occurrence": c["occurrence"], "axis": [0, 0, 1], "angle": "90 deg", "capture": false}));
+    let turned = run(&mut s, "component.properties", json!({"component": c["component"]}));
+    tensor_close(&turned["total"]["inertia_g_mm2"], [[iyy, 0.0, 0.0], [0.0, ixx, 0.0], [0.0, 0.0, izz]], 1e-9);
+    assert_eq!(turned["total"]["principal_moments_g_mm2"], total["principal_moments_g_mm2"]);
+    let x_axis = &turned["total"]["principal_axes"][2];
+    assert!(x_axis[0].as_f64().unwrap().abs() < 1e-9 && (x_axis[1].as_f64().unwrap().abs() - 1.0).abs() < 1e-9, "{turned}");
+}
+
+/// #8095: an assembly's tensor adds each placement's own about the shared centre of mass by
+/// parallel axes, and `about` takes it about any point; a cylinder's comes from its
+/// tessellation, close to m r² / 2 about its axis.
+#[test]
+fn assembly_inertia_adds_placements_by_parallel_axes_and_about_any_point() {
+    let mut s = Session::default();
+    let (component, _, body) = box_in(&mut s, "Block");
+    run(&mut s, "occurrence.copy", json!({"component": component, "translate": [20, 0, 0]}));
+    let root = run(&mut s, "component.properties", json!({"component": "root", "about": [0, 0, 0]}));
+    let total = &root["total"];
+    let m = s.doc.density(&body);
+    close(&total["mass_g"], 2.0 * m);
+    // Each 10 mm cube: m (10² + 10²) / 12 on its diagonal; each sits 10 mm along x from (15, 5, 5).
+    let own = m * 200.0 / 12.0;
+    let at_centre = [[2.0 * own, 0.0, 0.0], [0.0, 2.0 * own + 2.0 * m * 100.0, 0.0], [0.0, 0.0, 2.0 * own + 2.0 * m * 100.0]];
+    tensor_close(&total["inertia_g_mm2"], at_centre, 1e-9);
+    // About the origin: the parallel-axis term of the whole mass at (15, 5, 5).
+    let (mm, cv) = (2.0 * m, [15.0, 5.0, 5.0]);
+    let c2: f64 = cv.iter().map(|x| x * x).sum();
+    let at_origin = [0, 1, 2].map(|r| [0, 1, 2].map(|k| at_centre[r][k] + mm * (if r == k { c2 } else { 0.0 } - cv[r] * cv[k])));
+    assert_eq!(total["inertia_about"]["point"], json!([0.0, 0.0, 0.0]));
+    tensor_close(&total["inertia_about"]["inertia_g_mm2"], at_origin, 1e-9);
+    assert!(total.get("inertia_about").is_some() && run(&mut s, "component.properties", json!({}))["total"].get("inertia_about").is_none());
+
+    let mut s = Session::default();
+    run(&mut s, "solid.cylinder", json!({"radius": 8, "height": 10, "body_name": "Pin"}));
+    let r = run(&mut s, "component.properties", json!({}));
+    let (m, r2) = (r["total"]["mass_g"].as_f64().unwrap(), 64.0);
+    let i = tensor(&r["total"]["inertia_g_mm2"]);
+    assert!((i[2][2] - m * r2 / 2.0).abs() < 1e-3 * m * r2 / 2.0, "{i:?}");
+    assert!((i[0][0] - m * (3.0 * r2 + 100.0) / 12.0).abs() < 1e-3 * i[0][0], "{i:?}");
+}
+
+/// #8095: an open surface has no volume, so no tensor; the closed bodies beside it keep theirs.
+#[test]
+fn open_bodies_have_no_inertia_and_leave_the_closed_ones_alone() {
+    let mut s = Session::default();
+    for (command, params) in [
+        ("sketch.create", json!({"plane": "XY", "name": "Profile"})),
+        ("sketch.line", json!({"points": [[30, 0], [30, 40]], "ids": ["side"]})),
+        ("sketch.finish", json!({})),
+        ("surface.revolve", json!({"sketch": "Profile", "curves": ["side"], "axis": "y", "angle": "270 deg", "body_name": "Tube"})),
+    ] {
+        run(&mut s, command, params);
+    }
+    let open = run(&mut s, "component.properties", json!({"about": [1, 2, 3]}));
+    assert_eq!(open["bodies"][0]["inertia_g_mm2"], Value::Null);
+    for key in ["inertia_g_mm2", "principal_moments_g_mm2", "principal_axes"] {
+        assert_eq!(open["total"][key], Value::Null, "{key}");
+    }
+    assert_eq!(open["total"]["inertia_about"]["inertia_g_mm2"], Value::Null);
+    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [100, 0, 0], "body_name": "Box"}));
+    let both = run(&mut s, "component.properties", json!({}));
+    let m = both["total"]["mass_g"].as_f64().unwrap();
+    tensor_close(&both["total"]["inertia_g_mm2"], [[m * 200.0 / 12.0, 0.0, 0.0], [0.0, m * 200.0 / 12.0, 0.0], [0.0, 0.0, m * 200.0 / 12.0]], 1e-9);
 }
 
 #[test]
diff --git a/crates/geom/src/inertia.rs b/crates/geom/src/inertia.rs
new file mode 100644
index 0000000000..3ff6db48d1
--- /dev/null
+++ b/crates/geom/src/inertia.rs
@@ -0,0 +1,158 @@
+//! Inertia tensors (#8095): built from how a body's volume spreads about its centre of mass,
+//! taken about another point (parallel axes), and their principal moments and axes.
+
+use crate::{MassProperties, Vec3};
+
+/// A symmetric 3 × 3 tensor, row by row.
+pub type Tensor3 = [[f64; 3]; 3];
+
+/// Jacobi sweeps before [`principal`] gives up; a 3 × 3 tensor settles in well under ten.
+const MAX_SWEEPS: usize = 50;
+
+const IDENTITY3: Tensor3 = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
+
+impl MassProperties {
+    /// Second moments about the centroid per unit volume, ∫ (x − c)(x − c)ᵀ dV / V. Unlike the
+    /// inertia it follows any linear map L of the body as L G Lᵀ (a scale or a mirror too), and
+    /// [`from_gyration`] turns it into the inertia of a mass spread that way.
+    pub fn gyration(&self) -> Option<Tensor3> {
+        // I = tr(Σ) E − Σ, so tr(I) = 2 tr(Σ) and Σ = tr(I)/2 E − I.
+        let i = &self.inertia;
+        let half = (i[0][0] + i[1][1] + i[2][2]) / 2.0;
+        let mut g = [[0.0f64; 3]; 3];
+        for (row_out, (a, row)) in g.iter_mut().zip(i.iter().enumerate()) {
+            for (cell, (b, x)) in row_out.iter_mut().zip(row.iter().enumerate()) {
+                *cell = (if a == b { half } else { 0.0 } - x) / self.volume;
+            }
+        }
+        g.iter().flatten().all(|x| x.is_finite()).then_some(g)
+    }
+}
+
+/// The inertia tensor of `mass` spread as `gyration` about its centre of mass: m (tr(G) E − G).
+pub fn from_gyration(gyration: &Tensor3, mass: f64) -> Tensor3 {
+    let trace = gyration[0][0] + gyration[1][1] + gyration[2][2];
+    let mut out = [[0.0f64; 3]; 3];
+    for (i, (row_out, row)) in out.iter_mut().zip(gyration).enumerate() {
+        for (j, (cell, x)) in row_out.iter_mut().zip(row).enumerate() {
+            *cell = mass * (if i == j { trace } else { 0.0 } - x);
+        }
+    }
+    out
+}
+
+/// `g` of a body moved by the linear map `l` (row by row): L G Lᵀ. A gyration follows any
+/// linear map; an inertia tensor follows a rotation this way.
+pub fn transformed(g: &Tensor3, l: &Tensor3) -> Tensor3 {
+    mul(&mul(l, g), &transpose(l))
+}
+
+/// `inertia` of `mass` about its centre of mass, taken about a point `d` from that centre
+/// instead (parallel-axis theorem): I + m (|d|² E − d dᵀ).
+pub fn shifted(inertia: &Tensor3, mass: f64, d: Vec3) -> Tensor3 {
+    let dv = [d.x, d.y, d.z];
+    let d2 = d.dot(d);
+    let mut out = *inertia;
+    for (i, (row, di)) in out.iter_mut().zip(dv).enumerate() {
+        for (j, (cell, dj)) in row.iter_mut().zip(dv).enumerate() {
+            *cell += mass * (if i == j { d2 } else { 0.0 } - di * dj);
+        }
+    }
+    out
+}
+
+/// Principal moments of `inertia`, smallest first, and the unit axis each is about: the axes
+/// with no products of inertia between them. The first two point along the world axis each is
+/// nearest to, and the third is the first × the second (right-handed). Moments within `equal`
+/// (a share of the largest) of each other count as equal, as a round body's do though its
+/// tessellation tells them apart: their axes are free in the plane (or space) they share, and
+/// the world axes nearest it are given. `None` for a tensor with non-finite entries.
+pub fn principal(inertia: &Tensor3, equal: f64) -> Option<([f64; 3], [Vec3; 3])> {
+    if !inertia.iter().flatten().all(|x| x.is_finite()) {
+        return None;
+    }
+    // The symmetric part: products of inertia summed with round-off can differ in the last bit.
+    let mut a = *inertia;
+    for (i, row) in a.iter_mut().enumerate() {
+        for (j, cell) in row.iter_mut().enumerate() {
+            *cell = 0.5 * (inertia[i][j] + inertia[j][i]);
+        }
+    }
+    let scale = a.iter().flatten().fold(0.0f64, |m, x| m.max(x.abs()));
+    let mut v = IDENTITY3;
+    // Cyclic Jacobi: each rotation zeroes one product of inertia; the sweep repeats until all are
+    // round-off small against the largest entry.
+    for _ in 0..MAX_SWEEPS {
+        if a[0][1].abs() + a[0][2].abs() + a[1][2].abs() <= scale * 1e-15 {
+            break;
+        }
+        for (p, q) in [(0, 1), (0, 2), (1, 2)] {
+            let apq = a[p][q];
+            if apq == 0.0 {
+                continue;
+            }
+            let theta = (a[q][q] - a[p][p]) / (2.0 * apq);
+            let t = theta.signum() / (theta.abs() + (theta * theta + 1.0).sqrt());
+            let c = 1.0 / (t * t + 1.0).sqrt();
+            let s = t * c;
+            let mut j = IDENTITY3;
+            j[p][p] = c;
+            j[q][q] = c;
+            j[p][q] = s;
+            j[q][p] = -s;
+            a = mul(&mul(&transpose(&j), &a), &j);
+            v = mul(&v, &j);
+        }
+    }
+    let mut order = [0usize, 1, 2];
+    order.sort_by(|&x, &y| a[x][x].total_cmp(&a[y][y]));
+    let moments = order.map(|k| a[k][k]);
+    let [e0, e1, _] = order.map(|k| Vec3::new(v[0][k], v[1][k], v[2][k]));
+    let largest = moments.iter().fold(0.0f64, |m, x| m.max(x.abs()));
+    let same = |x: f64, y: f64| (y - x).abs() <= equal * largest;
+    let (low, high) = (same(moments[0], moments[1]), same(moments[1], moments[2]));
+    let (first, second) = if low && high {
+        (Vec3::X, Vec3::Y)
+    } else if low {
+        // The first two share a plane: the world axis nearest it, then its perpendicular there.
+        let normal = e0.cross(e1).normalized()?;
+        let first = nearest_in_plane(normal)?;
+        (first, normal.cross(first).normalized()?)
+    } else if high {
+        (e0, nearest_in_plane(e0)?)
+    } else {
+        (e0, e1)
+    };
+    let (first, second) = (forward(first), forward(second));
+    let axes = [first, second, first.cross(second)];
+    (moments.iter().all(|x| x.is_finite()) && axes.iter().all(|e| e.is_finite())).then_some((moments, axes))
+}
+
+/// `e` turned to point along the world axis it is nearest to, so the same body gives the same
+/// axes every time.
+fn forward(e: Vec3) -> Vec3 {
+    let lead = [e.x, e.y, e.z].into_iter().fold(0.0f64, |m, x| if x.abs() > m.abs() { x } else { m });
+    if lead < 0.0 { e * -1.0 } else { e }
+}
+
+/// The unit direction in the plane through the origin with unit `normal` nearest a world axis
+/// (X first when two are as near).
+fn nearest_in_plane(normal: Vec3) -> Option<Vec3> {
+    let along = |w: Vec3| w - normal * normal.dot(w);
+    let best = [Vec3::X, Vec3::Y, Vec3::Z].into_iter().map(along).fold(Vec3::ZERO, |b, p| if p.len2() > b.len2() * (1.0 + 1e-9) { p } else { b });
+    best.normalized()
+}
+
+fn mul(a: &Tensor3, b: &Tensor3) -> Tensor3 {
+    let mut out = [[0.0f64; 3]; 3];
+    for (row_out, row) in out.iter_mut().zip(a) {
+        for (j, cell) in row_out.iter_mut().enumerate() {
+            *cell = row.iter().zip(b).map(|(x, b_row)| x * b_row[j]).sum();
+        }
+    }
+    out
+}
+
+fn transpose(a: &Tensor3) -> Tensor3 {
+    [[a[0][0], a[1][0], a[2][0]], [a[0][1], a[1][1], a[2][1]], [a[0][2], a[1][2], a[2][2]]]
+}
diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index bef540a360..791270245d 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -25,6 +25,7 @@ pub mod fill;
 pub mod fill_general;
 mod grid;
 pub mod hlr;
+pub mod inertia;
 mod mesh;
 pub mod mesh_distance;
 pub mod network;
diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rs
index 6ff94beefd..ab25971b4e 100644
--- a/crates/geom/src/tests.rs
+++ b/crates/geom/src/tests.rs
@@ -530,6 +530,99 @@ fn mass_properties_need_consistently_oriented_faces() {
     assert!(m.mass_properties().is_none());
 }
 
+/// `m` with every vertex moved by the linear map `l` (row by row).
+fn mapped(m: &Mesh, l: &inertia::Tensor3) -> Mesh {
+    let apply = |p: Vec3| {
+        let [x, y, z] = l.map(|r| r[0] * p.x + r[1] * p.y + r[2] * p.z);
+        Vec3::new(x, y, z)
+    };
+    Mesh { positions: m.positions.iter().map(|p| apply(*p)).collect(), triangles: m.triangles.clone(), ..Default::default() }
+}
+
+fn tensors_close(a: &inertia::Tensor3, b: &inertia::Tensor3, tol: f64) -> bool {
+    a.iter().flatten().zip(b.iter().flatten()).all(|(x, y)| (x - y).abs() <= tol)
+}
+
+#[test]
+fn gyration_follows_a_rotation_a_scale_and_a_mirror_of_the_body() {
+    let base = offset_box(Vec3::new(5.0, -3.0, 2.0), 20.0, 30.0, 40.0);
+    let props = base.mass_properties().unwrap();
+    let g = props.gyration().unwrap();
+    assert!(tensors_close(&inertia::from_gyration(&g, props.volume), &props.inertia, 1e-6 * props.inertia[0][0]));
+    let (c, s) = (30f64.to_radians().cos(), 30f64.to_radians().sin());
+    let (cx, sx) = (20f64.to_radians().cos(), 20f64.to_radians().sin());
+    let turn_z = [[c, -s, 0.0], [s, c, 0.0], [0.0, 0.0, 1.0]];
+    let turn_x = [[1.0, 0.0, 0.0], [0.0, cx, -sx], [0.0, sx, cx]];
+    let turn = [0, 1, 2].map(|i| [0, 1, 2].map(|j| (0..3).map(|k| turn_z[i][k] * turn_x[k][j]).sum::<f64>()));
+    for l in [turn, [[2.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.5]], [[-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]] {
+        let moved = mapped(&base, &l).mass_properties().expect("a mapped box is still closed");
+        let want = moved.inertia;
+        let got = inertia::from_gyration(&inertia::transformed(&g, &l), moved.volume);
+        assert!(tensors_close(&got, &want, 1e-6 * want[0][0].abs().max(want[2][2].abs())), "{l:?}\n{got:?}\n{want:?}");
+    }
+}
+
+#[test]
+fn principal_axes_of_a_turned_box_are_its_edges() {
+    let (a, b, c) = (20.0, 30.0, 40.0);
+    let v = a * b * c;
+    let (cs, sn) = (30f64.to_radians().cos(), 30f64.to_radians().sin());
+    let turn = [[cs, -sn, 0.0], [sn, cs, 0.0], [0.0, 0.0, 1.0]];
+    let m = mapped(&offset_box(Vec3::ZERO, a, b, c), &turn).mass_properties().unwrap();
+    assert!(m.inertia[0][1].abs() > 1.0, "turned about z, the box has a product of inertia: {:?}", m.inertia);
+    let (moments, axes) = inertia::principal(&m.inertia, 0.0).unwrap();
+    // Smallest about the longest edge (z), largest about the shortest (the turned x).
+    let want = [v * (a * a + b * b) / 12.0, v * (a * a + c * c) / 12.0, v * (b * b + c * c) / 12.0];
+    for (got, want) in moments.iter().zip(want) {
+        assert!(close(*got, want, 1e-9), "{moments:?} {want}");
+    }
+    let edges = [Vec3::Z, Vec3::new(-sn, cs, 0.0), Vec3::new(cs, sn, 0.0)];
+    for (axis, edge) in axes.iter().zip(edges) {
+        assert!((axis.dot(edge).abs() - 1.0).abs() < 1e-9, "{axes:?}");
+    }
+    assert!((axes[0].cross(axes[1]) - axes[2]).len() < 1e-12, "right-handed: {axes:?}");
+    // The first two point along the world axis nearest them: +z, then +y.
+    assert!(axes[0].z > 0.0 && axes[1].y > 0.0, "{axes:?}");
+}
+
+#[test]
+fn shifted_inertia_about_a_box_corner_matches_the_closed_form() {
+    let (a, b, c) = (20.0, 30.0, 40.0);
+    let m = offset_box(Vec3::ZERO, a, b, c).mass_properties().unwrap();
+    let mass = 3.0 * m.volume;
+    let at_centre = m.inertia.map(|r| r.map(|x| 3.0 * x));
+    let corner = inertia::shifted(&at_centre, mass, Vec3::ZERO - m.centroid);
+    let want = [
+        [mass * (b * b + c * c) / 3.0, -mass * a * b / 4.0, -mass * a * c / 4.0],
+        [-mass * a * b / 4.0, mass * (a * a + c * c) / 3.0, -mass * b * c / 4.0],
+        [-mass * a * c / 4.0, -mass * b * c / 4.0, mass * (a * a + b * b) / 3.0],
+    ];
+    assert!(tensors_close(&corner, &want, 1e-9 * want[0][0]), "{corner:?}");
+}
+
+#[test]
+fn principal_axes_of_equal_zero_or_broken_tensors() {
+    let sphere = [[5.0, 0.0, 0.0], [0.0, 5.0, 0.0], [0.0, 0.0, 5.0]];
+    assert_eq!(inertia::principal(&sphere, 0.0), Some(([5.0; 3], [Vec3::X, Vec3::Y, Vec3::Z])));
+    assert_eq!(inertia::principal(&[[0.0; 3]; 3], 0.0), Some(([0.0; 3], [Vec3::X, Vec3::Y, Vec3::Z])));
+    assert!(inertia::principal(&[[f64::NAN, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], 0.0).is_none());
+    assert!(inertia::principal(&[[f64::INFINITY, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], 0.0).is_none());
+    // Products of inertia far larger than the moments still settle.
+    let (moments, _) = inertia::principal(&[[1.0, 1e12, 0.0], [1e12, 1.0, 0.0], [0.0, 0.0, 1.0]], 0.0).unwrap();
+    assert!(close(moments[0], -1e12, 1e-9) && close(moments[2], 1e12, 1e-9), "{moments:?}");
+    // A tessellated pin along z: x and y differ in the fifth digit, with a stray product between
+    // them. Exactly, their axes are turned at random; counted as equal, they are X and Y.
+    let pin = [[7.99497, -0.000535, 0.0], [-0.000535, 7.99536, 0.0], [0.0, 0.0, 5.18447]];
+    let (_, exact) = inertia::principal(&pin, 0.0).unwrap();
+    assert!(exact[1].x.abs() < 0.99, "{exact:?}");
+    assert_eq!(inertia::principal(&pin, 1e-3).map(|(_, axes)| axes), Some([Vec3::Z, Vec3::X, Vec3::Y]));
+    // The same with the round pair smallest (a disc), and all three alike (a cube's tessellation).
+    let disc = [[3.00001, 0.0002, 0.0], [0.0002, 3.0, 0.0], [0.0, 0.0, 6.0]];
+    assert_eq!(inertia::principal(&disc, 1e-3).map(|(_, axes)| axes), Some([Vec3::X, Vec3::Y, Vec3::Z]));
+    let cube = [[2.0, 1e-5, 0.0], [1e-5, 2.0001, 0.0], [0.0, 0.0, 1.9999]];
+    assert_eq!(inertia::principal(&cube, 1e-3).map(|(_, axes)| axes), Some([Vec3::X, Vec3::Y, Vec3::Z]));
+}
+
 mod close_pairs {
     use super::*;
 
diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs
index ff4e149582..b172a6467a 100644
--- a/crates/io/src/lib.rs
+++ b/crates/io/src/lib.rs
@@ -54,7 +54,7 @@ pub use threemf::{
 pub use urdf::{UrdfOptions, UrdfPackage, urdf};
 
 use solidcraft_doc::{Document, Metadata, ModelState};
-use solidcraft_geom::{Mesh, Vec3};
+use solidcraft_geom::{MassProperties, Mesh, Vec3};
 
 /// Design file extension: new designs, autosaves and recovery files are written as `.sc`.
 pub const DESIGN_EXT: &str = "sc";
@@ -425,6 +425,14 @@ fn weld_eps(b: &solidcraft_kernel::Body) -> f64 {
     (b.size() * 1e-6).max(1e-7)
 }
 
+/// Unit-density [`MassProperties`] of a body from its welded [`export_mesh`], the mesh URDF links
+/// take their inertia from; `None` when that mesh does not close (an open surface).
+pub fn mass_properties(b: &solidcraft_kernel::Body) -> Result<Option<MassProperties>> {
+    let m = export_mesh(b)?;
+    let (positions, triangles) = weld(&m.positions, &m.triangles, weld_eps(b));
+    Ok(Mesh { positions, triangles, ..Mesh::default() }.mass_properties())
+}
+
 /// Binary STL of several meshes (one solid).
 pub fn stl_binary(meshes: &[Mesh], name: &str) -> Vec<u8> {
     let n: usize = meshes.iter().map(|m| m.triangles.len()).sum();
diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs
index 66711152c6..f6af4d5532 100644
--- a/crates/ui-egui/src/context_menu.rs
+++ b/crates/ui-egui/src/context_menu.rs
@@ -231,6 +231,8 @@ pub struct MenuState {
     pub link_copies: Option<crate::linked_source::Copies>,
     /// The Properties window: title and measurements.
     pub props: Option<(String, Value)>,
+    /// Its measurement while it runs beside the window (#5203).
+    pub props_measuring: Option<crate::design_properties::Measuring>,
     /// The viewport menu opened over something: it offers Select Other.
     pub over_geometry: bool,
     /// The plane under the cursor when the viewport menu opened: it offers a sketch on it.
@@ -1381,16 +1383,8 @@ pub fn run_item(app: &mut SolveApp, item: &Item, at: Pos2) {
                 "inspect.measure"
             };
             let params = if command == "inspect.measure" { json!({ "bodies": bodies }) } else { p.clone() };
-            match app.session.execute(command, &params) {
-                Ok(v) => {
-                    let title = v["name"]
-                        .as_str()
-                        .map(str::to_string)
-                        .unwrap_or_else(|| if bodies.len() == 1 { bodies.join("") } else { format!("{} bodies", bodies.len()) });
-                    app.menu.props = Some((title, v));
-                }
-                Err(e) => app.set_status(e.to_string(), true),
-            }
+            let fallback = if bodies.len() == 1 { bodies.join("") } else { format!("{} bodies", bodies.len()) };
+            crate::design_properties::open_object(app, command, &params, fallback);
         }
         "ui.designProperties" => app.start("document.metadata"),
         "ui.export" => {
diff --git a/crates/ui-egui/src/design_properties.rs b/crates/ui-egui/src/design_properties.rs
index f845fb3464..92a66eb5c8 100644
--- a/crates/ui-egui/src/design_properties.rs
+++ b/crates/ui-egui/src/design_properties.rs
@@ -4,14 +4,19 @@
 //! Cancel and the close button change nothing. File → Design Properties…, the Browser's
 //! Document Settings, the root component's menu and `ui.start` of `document.metadata` or
 //! `document.metadata.set` open it. [`show_object`] draws the Properties card (mass, volume, area,
-//! centre of mass, bounding box, counts) of the body or component a menu asked about; both are
-//! `ui_kit::Window` cards.
+//! centre of mass, bounding box, counts, and for a component its first moments and moment of
+//! inertia: #8095) of the body or component a menu or Inspect → Measure → Properties asked
+//! about; both are `ui_kit::Window` cards. While the card is open, [`overlay`] marks the centre
+//! of mass in the view with the principal axes standing out of it.
 
-use serde_json::{Map, Value};
+use egui::{Align2, FontId, Stroke};
+use serde_json::{Map, Value, json};
 use solidcraft_engine::doc::metadata::{DESCRIPTION, Owner, keys};
+use solidcraft_engine::geom::Vec3;
 
 use crate::SolveApp;
 use crate::ui_kit;
+use crate::viewport::Proj;
 
 /// Longest preview of another tool's value in the list.
 const PREVIEW_CHARS: usize = 80;
@@ -115,9 +120,207 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
     app.design_properties = Some(d);
 }
 
+/// Open the Properties window on `command`'s reply (`component.properties`,
+/// `occurrence.properties` or `inspect.measure`), titled with the reply's name, else `fallback`.
+/// A refusal goes to the status line.
+pub fn open_object(app: &mut SolveApp, command: &str, params: &Value, fallback: String) {
+    close_object(app);
+    // A large assembly takes seconds to measure, which froze the window (#5203): measured on a
+    // copy beside it, the card shows when done. Headless and in tests (no wait set), here.
+    if let Some(wait) = app.apply_off_thread
+        && let Some(rx) = measure_beside(app.session.scratch(), command, params)
+    {
+        match rx.recv_timeout(wait) {
+            Ok(reply) => opened(app, reply, fallback),
+            Err(std::sync::mpsc::RecvTimeoutError::Timeout) => app.menu.props_measuring = Some(Measuring { fallback, rx }),
+            Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => app.set_status(app.tr("ui.properties.measuring_failed").to_string(), true),
+        }
+        return;
+    }
+    let reply = app.session.execute(command, params).map_err(|e| e.to_string());
+    opened(app, reply, fallback);
+}
+
+/// Close the Properties card, and drop a measurement still running for it.
+pub fn close_object(app: &mut SolveApp) {
+    app.menu.props = None;
+    app.menu.props_measuring = None;
+}
+
+/// A Properties measurement running beside the window (#5203): the card's title when the reply
+/// has no name, and the reply to come.
+pub struct Measuring {
+    fallback: String,
+    rx: std::sync::mpsc::Receiver<Result<Value, String>>,
+}
+
+/// Show `reply` in the card, titled with its name (else `fallback`); a refusal goes to the
+/// status line.
+fn opened(app: &mut SolveApp, reply: Result<Value, String>, fallback: String) {
+    match reply {
+        Ok(v) => {
+            let title = v["name"].as_str().map(str::to_string).unwrap_or(fallback);
+            app.menu.props = Some((title, v));
+        }
+        Err(e) => app.set_status(e, true),
+    }
+}
+
+/// Run `command` on `copy` on a worker; the reply comes on the returned channel.
+#[cfg(not(target_arch = "wasm32"))]
+fn measure_beside(mut copy: solidcraft_engine::Session, command: &str, params: &Value) -> Option<std::sync::mpsc::Receiver<Result<Value, String>>> {
+    let (tx, rx) = std::sync::mpsc::channel();
+    let (command, params) = (command.to_string(), params.clone());
+    std::thread::Builder::new()
+        .name("properties".into())
+        .spawn(move || {
+            let _ = tx.send(copy.execute(&command, &params).map_err(|e| e.to_string()));
+        })
+        .ok()?;
+    Some(rx)
+}
+
+/// No threads on the web: measured here.
+#[cfg(target_arch = "wasm32")]
+fn measure_beside(_copy: solidcraft_engine::Session, _command: &str, _params: &Value) -> Option<std::sync::mpsc::Receiver<Result<Value, String>>> {
+    None
+}
+
+/// While a measurement runs beside the window: a card saying so (Close drops it), and the
+/// Properties card in its place once the reply is in.
+fn show_measuring(app: &mut SolveApp, ctx: &egui::Context) {
+    let Some(m) = app.menu.props_measuring.take() else { return };
+    match m.rx.try_recv() {
+        Ok(reply) => return opened(app, reply, m.fallback),
+        Err(std::sync::mpsc::TryRecvError::Disconnected) => return app.set_status(app.tr("ui.properties.measuring_failed").to_string(), true),
+        Err(std::sync::mpsc::TryRecvError::Empty) => {}
+    }
+    ctx.request_repaint_after(std::time::Duration::from_millis(100));
+    let (heading, text) = (app.tr("ui.properties").to_string(), app.tr("ui.properties.measuring").to_string());
+    let (closed, action) = ui_kit::Window::new(egui::Id::new("sc_props"), "settings", &heading).actions("", "Close", None).show(ctx, true, |ui| {
+        ui.horizontal(|ui| {
+            ui.spinner();
+            ui_kit::text(ui, &text, ui_kit::Text::Note("measuring"));
+        });
+    });
+    if !(closed || action == ui_kit::Action::Cancel) {
+        app.menu.props_measuring = Some(m);
+    }
+}
+
+/// Inspect → Measure → Properties (#8095): the window of the one selected placement, else of the
+/// active component (at the root, the whole design).
+pub fn open_selected(app: &mut SolveApp) {
+    let (command, params) = match app.session.selection.as_slice() {
+        [solidcraft_engine::Sel::Occurrence { path }] if !path.is_empty() => {
+            ("occurrence.properties", json!({"occurrence": path.last(), "path": path}))
+        }
+        _ => ("component.properties", json!({})),
+    };
+    open_object(app, command, &params, String::new());
+}
+
+/// A reply's 3 × 3 tensor, row by row.
+fn tensor(v: &Value) -> Option<[[f64; 3]; 3]> {
+    let row = |r: &Value| -> Option<[f64; 3]> { Some([r.get(0)?.as_f64()?, r.get(1)?.as_f64()?, r.get(2)?.as_f64()?]) };
+    Some([row(v.get(0)?)?, row(v.get(1)?)?, row(v.get(2)?)?])
+}
+
+fn point(v: &Value) -> Option<Vec3> {
+    Some(Vec3::new(v.get(0)?.as_f64()?, v.get(1)?.as_f64()?, v.get(2)?.as_f64()?))
+}
+
+/// `x` with the length decimals, or with more where those would leave fewer than three
+/// significant digits; never a signed zero.
+fn number_text(app: &SolveApp, x: f64) -> String {
+    let decimals = i32::from(app.preferences.length_decimals.min(8));
+    let lead = if x == 0.0 || !x.is_finite() { 0 } else { x.abs().log10().floor() as i32 };
+    let digits = decimals.max(2 - lead).clamp(0, 12);
+    let x = if x.abs() < 0.5 * 10f64.powi(-digits) { 0.0 } else { x };
+    format!("{x:.*}", digits as usize)
+}
+
+/// The tensor the window shows (#8095): in g × the design's length unit squared, with the
+/// products of inertia that are round-off against the largest entry as zero.
+fn shown_tensor(app: &SolveApp, total: &Value) -> Option<[[f64; 3]; 3]> {
+    let k = crate::prefs::unit_scale(&app.session.doc.units).0;
+    let i = tensor(&total["inertia_g_mm2"])?.map(|r| r.map(|x| x * k * k));
+    let largest = i.iter().flatten().fold(0.0f64, |m, x| m.max(x.abs()));
+    Some(i.map(|r| r.map(|x| if x.abs() <= 1e-9 * largest { 0.0 } else { x })))
+}
+
+/// What Copy matrix puts on the clipboard: the shown tensor's rows at full precision, the values
+/// tab-separated, so it pastes as a 3 × 3 grid into a spreadsheet and splits easily in code.
+fn tensor_text(t: &[[f64; 3]; 3]) -> String {
+    t.iter().map(|r| r.map(|x| x.to_string()).join("\t")).collect::<Vec<_>>().join("\n")
+}
+
+/// The rows under Moment of inertia (#8095): label and cells, the tensor's three first.
+fn inertia_rows(app: &SolveApp, total: &Value) -> Vec<(String, Vec<String>)> {
+    let k = crate::prefs::unit_scale(&app.session.doc.units).0;
+    let Some(i) = shown_tensor(app, total) else {
+        return Vec::new();
+    };
+    let mut rows: Vec<(String, Vec<String>)> = ["x", "y", "z"]
+        .iter()
+        .zip(i)
+        .map(|(axis, r)| (app.tr(&format!("ui.properties.inertia_{axis}")).to_string(), r.map(|x| number_text(app, x)).to_vec()))
+        .collect();
+    if let Some(moments) = total["principal_moments_g_mm2"].as_array() {
+        let moments = moments.iter().map(|m| number_text(app, m.as_f64().unwrap_or(f64::NAN) * k * k)).collect();
+        rows.push((app.tr("ui.properties.principal_moments").to_string(), moments));
+    }
+    for (n, axis) in total["principal_axes"].as_array().into_iter().flatten().enumerate() {
+        let Some(e) = point(axis) else { continue };
+        let label = crate::i18n::format("ui.properties.principal_axis", &[("number", &(n + 1).to_string())]);
+        rows.push((label, [e.x, e.y, e.z].map(|x| format!("{:.4}", if x.abs() < 5e-5 { 0.0 } else { x })).to_vec()));
+    }
+    rows
+}
+
+/// The window's title: just Properties for the whole design (its name would only be the
+/// file's), else with the name of the component, placement or bodies it measured.
+fn window_title(title: &str, v: &Value) -> String {
+    if v["component"].as_u64() == Some(0) {
+        crate::i18n::tr("ui.properties").to_string()
+    } else {
+        crate::i18n::format("properties.title", &[("name", title)])
+    }
+}
+
+/// The centre of mass the window shows, its principal axes when it has them, and how long to
+/// draw them: a third of the bounding box's diagonal.
+fn centre_and_axes(v: &Value) -> Option<(Vec3, Vec<Vec3>, f64)> {
+    let total = &v["total"];
+    let bodies = v["bodies"].as_array();
+    let geometry = if total["center_of_mass"].is_array() { total } else { bodies.filter(|b| b.len() == 1)?.first()? };
+    let centre = point(&geometry["center_of_mass"])?;
+    let axes = total["principal_axes"].as_array().into_iter().flatten().filter_map(point).collect();
+    let reach = point(&geometry["bbox"]["max"]).zip(point(&geometry["bbox"]["min"])).map(|(a, b)| (a - b).len() / 3.0);
+    Some((centre, axes, reach.filter(|r| r.is_finite() && *r > 0.0).unwrap_or(10.0)))
+}
+
+/// While the Properties window is open: its centre of mass, with each principal axis standing
+/// out of it in the X, Y and Z colours in turn and numbered as the window lists them (#8095).
+pub fn overlay(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
+    let Some((centre, axes, reach)) = app.menu.props.as_ref().and_then(|(_, v)| centre_and_axes(v)) else { return };
+    let Some(at) = proj.to_screen(centre) else { return };
+    let tk = crate::theme::Tokens::view();
+    for (n, (axis, colour)) in axes.iter().zip(tk.axes()).enumerate() {
+        let Some(tip) = proj.to_screen(centre + *axis * reach) else { continue };
+        painter.line_segment([at, tip], Stroke::new(2.0, colour));
+        painter.text(tip, Align2::LEFT_BOTTOM, (n + 1).to_string(), FontId::proportional(tk.font_small), colour);
+    }
+    painter.circle(at, 6.0, tk.panel.gamma_multiply(0.8), Stroke::new(1.6, tk.accent));
+    painter.line_segment([at - egui::vec2(10.0, 0.0), at + egui::vec2(10.0, 0.0)], Stroke::new(1.2, tk.accent));
+    painter.line_segment([at - egui::vec2(0.0, 10.0), at + egui::vec2(0.0, 10.0)], Stroke::new(1.2, tk.accent));
+}
+
 /// Draw the Properties window of the body or component the menu asked about (mass, volume,
-/// area, centre of mass, bounding box and counts), when it is open. Close dismisses it.
+/// area, centre of mass, bounding box and counts; a component's first moments and moment of
+/// inertia), when it is open. Close dismisses it.
 pub fn show_object(app: &mut SolveApp, ctx: &egui::Context) {
+    show_measuring(app, ctx);
     let Some((title, v)) = app.menu.props.clone() else { return };
     let number = |x: &Value, k: &str| x.get(k).and_then(Value::as_f64).unwrap_or(f64::NAN);
     let mut rows: Vec<(&str, String)> = Vec::new();
@@ -155,14 +358,64 @@ pub fn show_object(app: &mut SolveApp, ctx: &egui::Context) {
         }
     }
     rows.push(("Faces / edges / vertices", format!("{} / {} / {}", total["faces"], total["edges"], total["vertices"])));
-    let heading = crate::i18n::format("properties.title", &[("name", &title)]);
+    let (k, unit) = crate::prefs::unit_scale(&app.session.doc.units);
+    let first = point(&total["first_moment_g_mm"]).filter(|_| number(total, "mass_g") > 0.0).map(|m| {
+        let m: Vec<String> = [m.x, m.y, m.z].iter().map(|x| number_text(app, x * k)).collect();
+        format!("({}) g·{unit}", m.join(", "))
+    });
+    let inertia = inertia_rows(app, total);
+    let note = crate::i18n::format("ui.properties.inertia_note", &[("unit", unit)]);
+    // A component's closed bodies have mass, but a mesh that would not close gave no tensor.
+    let unavailable =
+        inertia.is_empty() && total["inertia_g_mm2"].is_null() && number(total, "mass_g") > 0.0 && total.get("first_moment_g_mm").is_some();
+    let (first_label, section, unavailable_text) = (
+        app.tr("ui.properties.first_moments").to_string(),
+        app.tr("ui.properties.inertia").to_string(),
+        app.tr("ui.properties.inertia_unavailable").to_string(),
+    );
+    let copy = shown_tensor(app, total).map(|t| tensor_text(&t));
+    let copy_label = app.tr("ui.properties.copy_matrix").to_string();
+    let heading = window_title(&title, &v);
     let (closed, action) = ui_kit::Window::new(egui::Id::new("sc_props"), "settings", &heading).actions("", "Close", None).show(ctx, true, |ui| {
         for (label, value) in &rows {
             ui_kit::row(ui, crate::i18n::tr_label(label), |ui| ui_kit::text(ui, value, ui_kit::Text::Cell));
         }
+        if let Some(first) = &first {
+            ui_kit::row(ui, &first_label, |ui| ui_kit::text(ui, first, ui_kit::Text::Cell));
+        }
+        if !inertia.is_empty() || unavailable {
+            ui_kit::section(ui, "sc_props_inertia", &section, true, |ui| {
+                if unavailable {
+                    ui_kit::text(ui, &unavailable_text, ui_kit::Text::Note("inertia_unavailable"));
+                    return;
+                }
+                ui_kit::text(ui, &note, ui_kit::Text::Note("inertia_note"));
+                for (n, (label, cells)) in inertia.iter().enumerate() {
+                    ui_kit::row(ui, label, |ui| {
+                        ui.columns(cells.len(), |columns| {
+                            for (column, cell) in columns.iter_mut().zip(cells) {
+                                ui_kit::text(column, cell, ui_kit::Text::MonoCell);
+                            }
+                        })
+                    });
+                    // Under the tensor's last row: copy it whole.
+                    if n == 2
+                        && let Some(text) = &copy
+                    {
+                        ui_kit::row(ui, "", |ui| {
+                            let button = ui_kit::button(ui, &copy_label, ui_kit::Button::Small);
+                            crate::scenario::publish_handle("properties:copy_inertia", button.rect.center());
+                            if button.clicked() {
+                                ui.ctx().copy_text(text.clone());
+                            }
+                        });
+                    }
+                }
+            });
+        }
     });
     if closed || action == ui_kit::Action::Cancel {
-        app.menu.props = None;
+        close_object(app);
     }
 }
 
@@ -188,7 +441,7 @@ mod tests {
         h.frames(2);
         assert!(h.widget("Open surface — no volume").is_some());
         assert!(h.widget("Area").is_some());
-        for label in ["Volume", "Density", "Mass", "Center of mass"] {
+        for label in ["Volume", "Density", "Mass", "Center of mass", "First moments", "Moment of inertia"] {
             assert!(h.widget(label).is_none(), "{label} must not be shown for an open surface");
         }
         assert!(h.widget("Open bodies (no volume)").is_none());
@@ -264,6 +517,106 @@ mod tests {
         assert!(h.widget("Other tools' data (1)").is_some(), "the unknown key is listed with other tools' data");
     }
 
+    /// #8095: Inspect → Measure → Properties opens the window (it used to run the command and
+    /// show nothing), with a component's first moments and moment of inertia; the view marks
+    /// its centre of mass with three principal axes a third of the box's diagonal long.
+    #[test]
+    fn the_measure_panels_properties_button_opens_the_window_with_the_moment_of_inertia() {
+        use solidcraft_engine::geom::Vec3;
+        let mut h = Harness::new();
+        h.app.run("solid.box", json!({"length": 10, "width": 20, "height": 30, "body_name": "Block"})).unwrap();
+        h.step(&json!({"start": "component.properties"})).unwrap();
+        h.frames(2);
+        let (_, v) = h.app.menu.props.clone().expect("the button opens the window");
+        assert!(v["total"]["inertia_g_mm2"].is_array(), "{v}");
+        for label in ["First moments", "Moment of inertia", "Ixx, Ixy, Ixz", "Izx, Izy, Izz", "Principal moments", "Principal axis 3"] {
+            assert!(h.widget(label).is_some(), "{label}");
+        }
+        let (centre, axes, reach) = super::centre_and_axes(&v).unwrap();
+        assert!((centre - Vec3::new(5.0, 10.0, 15.0)).len() < 1e-9, "{centre:?}");
+        assert_eq!(axes, [Vec3::Z, Vec3::Y, Vec3::X * -1.0]);
+        assert!((reach - 1400f64.sqrt() / 3.0).abs() < 1e-9, "{reach}");
+        assert_eq!(super::window_title("Untitled", &v), "Properties", "the whole design's card has no file name in its title");
+
+        // Copy matrix: the shown tensor, three tab-separated rows at full precision.
+        // The card settles its size over a few frames: click where the button ends up.
+        h.frames(3);
+        let [x, y] = h.widget("Copy matrix").expect("the Copy matrix button");
+        let (request, _reply) = crate::control::ControlRequest::new("ui.click", json!({"x": x, "y": y}));
+        crate::control::handle(&mut h.app, &h.ctx, &request);
+        let mut copied = Vec::new();
+        for _ in 0..4 {
+            h.frame();
+            copied.extend(h.output.commands.iter().filter_map(|c| match c {
+                egui::OutputCommand::CopyText(text) => Some(text.clone()),
+                _ => None,
+            }));
+        }
+        let text = copied.last().expect("Copy matrix puts the tensor on the clipboard");
+        let rows: Vec<Vec<f64>> = text.lines().map(|l| l.split('\t').map(|x| x.parse().unwrap()).collect()).collect();
+        let want = super::shown_tensor(&h.app, &v["total"]).unwrap();
+        assert_eq!(rows, want.map(|r| r.to_vec()).to_vec(), "{text}");
+        let m = v["total"]["mass_g"].as_f64().unwrap();
+        assert!((rows[0][0] - m * (400.0 + 900.0) / 12.0).abs() < 1e-6 * rows[0][0] && rows[0][1] == 0.0, "{text}");
+        h.step(&json!({"widget": "Close"})).unwrap();
+        assert!(h.app.menu.props.is_none());
+
+        // One selected placement: its own properties, by its path.
+        let c = h.app.run("component.create", json!({"name": "Pin", "grounded": false})).unwrap();
+        h.app.run("solid.cylinder", json!({"radius": 4, "height": 10, "base": [50, 0, 0]})).unwrap();
+        let occurrence = c["occurrence"].as_u64().unwrap();
+        h.app.session.selection = vec![solidcraft_engine::Sel::Occurrence { path: vec![occurrence] }];
+        h.step(&json!({"start": "component.properties"})).unwrap();
+        let (title, v) = h.app.menu.props.clone().expect("the window opens on the placement");
+        assert_eq!((title.as_str(), v["occurrence"].as_u64()), ("Pin:1", Some(occurrence)), "{v}");
+        assert_eq!(super::window_title(&title, &v), "Properties: Pin:1", "a placement's card keeps its name");
+        let (_, axes, _) = super::centre_and_axes(&v).unwrap();
+        for (axis, want) in axes.iter().zip([Vec3::Z, Vec3::X, Vec3::Y]) {
+            assert!((*axis - want).len() < 1e-9, "a round pin's axes are the world axes: {axes:?}");
+        }
+    }
+
+    /// #5203: Properties on a large assembly took seconds on the window thread, which froze it.
+    /// Measured on a copy beside the window (here never waited for), the card says it is
+    /// measuring and shows the reply once it is in; Close drops a measurement still running.
+    #[test]
+    fn properties_measure_beside_the_window_and_show_when_done() {
+        let mut h = Harness::new();
+        h.app.run("solid.box", json!({"length": 10, "width": 20, "height": 30, "body_name": "Block"})).unwrap();
+        let here = h.app.session.execute("component.properties", &json!({})).unwrap();
+        h.app.apply_off_thread = Some(std::time::Duration::ZERO);
+        super::open_object(&mut h.app, "component.properties", &json!({}), String::new());
+        assert!(h.app.menu.props.is_none(), "nothing is waited for on the window thread");
+        let m = h.app.menu.props_measuring.take().expect("measuring beside the window");
+        assert_eq!(m.rx.recv().unwrap().unwrap(), here, "the copy measures what the design here does");
+
+        let (tx, rx) = std::sync::mpsc::channel();
+        h.app.menu.props_measuring = Some(super::Measuring { fallback: String::new(), rx });
+        h.frames(2);
+        assert!(h.widget("Measuring…").is_some() && h.app.menu.props.is_none());
+        tx.send(Ok(here.clone())).unwrap();
+        h.frames(2);
+        assert_eq!(h.app.menu.props.as_ref().map(|(_, v)| v), Some(&here));
+        assert!(h.widget("Moment of inertia").is_some());
+
+        let (_tx, rx) = std::sync::mpsc::channel::<Result<serde_json::Value, String>>();
+        super::close_object(&mut h.app);
+        h.app.menu.props_measuring = Some(super::Measuring { fallback: String::new(), rx });
+        h.frames(2);
+        h.step(&json!({"widget": "Close"})).unwrap();
+        assert!(h.app.menu.props_measuring.is_none() && h.app.menu.props.is_none(), "Close drops the measurement");
+    }
+
+    #[test]
+    fn moments_keep_three_significant_digits_and_no_signed_zero() {
+        let h = Harness::new();
+        let decimals = usize::from(h.app.preferences.length_decimals);
+        assert_eq!(super::number_text(&h.app, 1234.5678), format!("{:.decimals$}", 1234.5678));
+        assert_eq!(super::number_text(&h.app, 0.000_012_34), "0.0000123");
+        assert!(!super::number_text(&h.app, -1e-30).starts_with('-'));
+        assert_eq!(super::number_text(&h.app, 0.0), format!("{:.decimals$}", 0.0));
+    }
+
     #[test]
     fn the_file_menu_browser_and_root_component_open_the_window() {
         let mut h = Harness::new();
diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rs
index 68dea98b70..05743aaa5d 100644
--- a/crates/ui-egui/src/documents.rs
+++ b/crates/ui-egui/src/documents.rs
@@ -148,7 +148,7 @@ fn swap_in(app: &mut SolveApp, mut slot: DocSlot) -> DocSlot {
     app.viewport.orbit_free = None;
     app.preview.reset();
     app.viewport.hover = None;
-    app.menu.props = None;
+    crate::design_properties::close_object(app);
     crate::sketch_attachment_ui::clear(app);
     crate::agent_chat::leave_document(app);
     app.agent_chat.swap_document(&mut slot.agent_chat);
@@ -367,7 +367,7 @@ pub fn adopt(app: &mut SolveApp, session: Session) {
         reset_chat(app);
         crate::dialogs::cancel(app);
         app.tool = None;
-        app.menu.props = None;
+        crate::design_properties::close_object(app);
         crate::sketch_attachment_ui::clear(app);
         app.session.replace_design(session);
         // The blank design's record of its links goes with it; the new one's start now.
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index f5fe316675..632833d4e6 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -1299,6 +1299,7 @@ impl SolveApp {
                     self.edit_in_place.active = None;
                     render_workspace::reset_document(self);
                     dim_view::cancel();
+                    design_properties::close_object(self);
                     timeline::stop_playback(self);
                     self.menu.props = None;
                     sketch_attachment_ui::clear(self);
@@ -1618,6 +1619,11 @@ impl SolveApp {
             bom_panel::open(self);
             return;
         }
+        // Inspect → Measure → Properties: the window, not a reply nobody sees (#8095).
+        if matches!(id, "component.properties" | "occurrence.properties") {
+            design_properties::open_selected(self);
+            return;
+        }
         if id == "sketch.finish" {
             self.finish_sketch();
             return;
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index 73a2514a84..203273b51b 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -4801,6 +4801,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
     }
     crate::canvas::show(app, ui, &painter, &proj);
     crate::sketch_tools::show(app, ui, &painter, &proj);
+    crate::design_properties::overlay(app, &painter, &proj);
     crate::sketch_dims::show(app, ui, &proj);
     crate::select_other::show(app, ui.ctx());
     axis_view(app, ui, rect);
diff --git a/crates/ui-egui/tests/window_widths.rs b/crates/ui-egui/tests/window_widths.rs
index 6a65e0ec50..1e3d1c1fda 100644
--- a/crates/ui-egui/tests/window_widths.rs
+++ b/crates/ui-egui/tests/window_widths.rs
@@ -105,6 +105,8 @@ fn command_dialogs_shrink_to_their_content_within_limits() {
         h.app.params = None;
         h.app.design_properties = None;
         h.app.bom = None;
+        // Properties (Inspect → Measure) opens the Properties card.
+        h.app.menu.props = None;
         if spec.id == "material.properties.validate" {
             h.step(&json!({"click":{"handle":"dialog:close"}})).unwrap();
         }
diff --git a/docs/assembly-properties.md b/docs/assembly-properties.md
index 588f5cc4a3..0358b336c1 100644
--- a/docs/assembly-properties.md
+++ b/docs/assembly-properties.md
@@ -2,8 +2,15 @@
 
 The Browser's component **Properties** action measures the selected assembly placement,
 including its nested components. Select the root design to measure every instance in the
-assembly. The window shows material-aware mass, volume, surface area, center of mass and
-the world bounding box. Pending occurrence moves are included without capturing them.
+assembly. **Inspect → Measure → Properties** opens the same window for the one selected
+placement, or else for the active component. The window shows material-aware mass, volume,
+surface area, center of mass, first moments, the moment of inertia and the world bounding box.
+Pending occurrence moves are included without capturing them. While the window is open, the
+view marks the center of mass with its principal axes, numbered and colored as the window
+lists them. **Copy matrix**, under the tensor, puts it on the clipboard: three lines of
+tab-separated values at full precision, in the units shown, ready to paste into a spreadsheet
+or code. The window for the whole design is titled just **Properties**; one opened on a
+component, placement or bodies carries its name.
 
 The same measurements are available through commands:
 
@@ -12,6 +19,7 @@ The same measurements are available through commands:
 {"command":"component.properties","params":{"component":"root"}}
 {"command":"component.properties","params":{"component":"Subassembly","descendants":false}}
 {"command":"occurrence.properties","params":{"occurrence":"Bracket:2"}}
+{"command":"component.properties","params":{"component":"root","about":[0,0,0]}}
 ```
 
 `component.properties` defaults to the active component and measures its first placement.
@@ -31,3 +39,33 @@ kernel's tessellation-based body measurement. An empty component reports zero to
 null center of mass and bounding box. A failed body measurement returns an error instead of
 presenting an incomplete assembly total. These commands leave geometry, pending placements
 and undo history unchanged.
+
+## Moment of inertia
+
+Each closed body's entry has `inertia_g_mm2`: its inertia tensor about its own center of mass,
+in world axes, in g·mm². The `total` object has:
+
+- `first_moment_g_mm`: the first moments of mass, Σ m·c (the total mass times the center of
+  mass).
+- `inertia_g_mm2`: the inertia tensor about the total center of mass, in world axes. Each body's
+  own tensor is moved there with the parallel-axis theorem.
+- `principal_moments_g_mm2` (smallest first) and `principal_axes` (unit vectors, one per
+  moment). The first two axes point along the world axis each is nearest to; the third is the
+  first × the second, so the three make a right-handed frame. Moments within 0.1% of the largest
+  count as equal, as a round body's two equal moments do. Their axes are then the world axes
+  nearest the plane they share.
+- `inertia_about`, only when the command has `about: [x, y, z]` (mm, world): `{point,
+  inertia_g_mm2}`, the tensor about that point in world axes.
+
+The tensor is the matrix that turns an angular velocity into angular momentum. Its diagonal holds
+the moments of inertia (Ixx = ∫ (y² + z²) dm …), and the off-diagonal terms are the negated
+products of inertia (Ixy = −∫ x y dm …), the convention URDF and most dynamics libraries take. For
+kg·m², divide by 10⁹.
+
+The tensor is integrated over each body's welded export mesh, the one URDF export takes its
+inertia from. It is then scaled to the body's measured mass, so it agrees with the mass and center
+of mass shown. Planar bodies are exact. A round body is within about 0.1% at the standard export
+quality. Each body is tessellated once, however many times the assembly places it; each placement
+turns its tensor. A closed body whose mesh does not close has `inertia_g_mm2: null`, and so does
+the total. Open bodies have no volume, so they have no tensor either, and the total leaves them
+out.
diff --git a/docs/book/src/guide/assemblies.md b/docs/book/src/guide/assemblies.md
index 859b387326..215f486d88 100644
--- a/docs/book/src/guide/assemblies.md
+++ b/docs/book/src/guide/assemblies.md
@@ -400,8 +400,11 @@ joint still describes the intended connection.
 
 STEP export writes the component tree as an assembly.
 
-Right-click a component in the Browser and choose **Properties** to inspect
-material-aware mass, volume, surface area, centre of mass and world bounds. Descendants and
+Right-click a component in the Browser and choose **Properties**, or use **Inspect → Measure →
+Properties** for the selected placement or the active component, to inspect material-aware
+mass, volume, surface area, centre of mass, first moments, moment of inertia and world bounds.
+While the window is open, the view marks the centre of mass with the three principal axes
+standing out of it. Descendants and
 repeated instances contribute to assembly totals; pending moves are included. A component
 uses its first placement; `occurrence.properties` selects a specific instance. Root Properties
 measures the complete assembly. Volumes are summed, including overlapping bodies, rather than
diff --git a/docs/book/src/reference/glossary.md b/docs/book/src/reference/glossary.md
index 3af6bfd4be..8db9be95f2 100644
--- a/docs/book/src/reference/glossary.md
+++ b/docs/book/src/reference/glossary.md
@@ -260,6 +260,22 @@ A material sets mass, centre of gravity and strength values. How the body looks
 - **Elsewhere:** material, physical material.
 - **For translators:** not an appearance.
 
+### moment of inertia
+
+How a body's mass resists turning about an axis: the mass times the square of its distance from
+that axis, summed over the body.
+
+SolidCraft reports the whole inertia tensor about the centre of mass in world axes, with its
+*principal moments* and *principal axes*: the three axes with no products of inertia between
+them. The *first moments* are the mass times the centre of mass.
+
+- **In SolidCraft:** `inertia_g_mm2`, `principal_moments_g_mm2`, `principal_axes`,
+  `first_moment_g_mm` and `about` in `component.properties` and `occurrence.properties`; the
+  Properties window's Moment of inertia section.
+- **Don't use:** rotational inertia, second moment of mass, mass moment.
+- **Elsewhere:** moment of inertia, inertia tensor, mass moment of inertia.
+- **For translators:** not the second moment of area of a cross-section, a different quantity.
+
 ### occurrence
 
 One placed copy of a component inside its parent component.
diff --git a/skills/solidcraft-mechanisms/SKILL.md b/skills/solidcraft-mechanisms/SKILL.md
index 9e9fc6aec5..53b7e3894c 100644
--- a/skills/solidcraft-mechanisms/SKILL.md
+++ b/skills/solidcraft-mechanisms/SKILL.md
@@ -62,7 +62,7 @@ Written against SolidCraft `main` after 0.11.1, which counts the degrees of free
 - **Sweep until contact:** `joint.sweep {"joint":..., "from":0, "to":120, "occurrences":[...], "against":[...], "report_gaps":true}` answers how far a hinge, door or linkage opens: `stopped_at` (last clear value, bisected to `refine` mm, default 0.01), `stopped_by` `{a, b, at}` (or `"loop"`, `"limit"`), per-sample `min_gap_mm` and the nearest each part came (`min_gap`). It runs on a copy; `"apply":true` leaves the design at the stop. Pairs touching at `from` (`touching_at_start`) stop it only once they pass into each other.
 
 ## Verify
-- **Each joint:** `execute occurrence.properties {"occurrence":"Wing:1"}` (under 1 KB) gives the world bbox and centre of mass of one occurrence. Joining must not move them.
+- **Each joint:** `execute occurrence.properties {"occurrence":"Wing:1"}` (about 2 KB) gives the world bbox, centre of mass and inertia of one occurrence. Joining must not move them.
 - **Each drive:** compute the expected value of every follower, and read it back from `joint.list` (degrees and mm, with `unit`). For an actuator from root R to tip T on a panel hinged at H: `L(θ) = |T(θ) - R|`, where `T(θ)` is T turned by θ about the hinge axis through H, and the stroke is `L(θ) - L(0)`. A closed loop matches to 1e-6 mm.
 - **Each stop:** solve for where the limit is reached, and compare with the value the drive stopped at. Stops are found by bisection, so they land within about 0.01 degrees.
 - **Links:** b must equal r·a + o exactly, unless that is outside b's limits; then b sits at the limit and the mirror stops following.