Modeling a nut, in Rust

Satoshi Misumi — Mon, 18 May 2026 18:24:40 +0000

I tried to build one ISO 4032 M2 hex nut with the Rust cadrum crate (an OpenCASCADE-based B-Rep library), and there were more detours than I expected, so I'm leaving the notes here.

I started with just a cube and grew main.rs over 6 stages, adding one feature at a time. Every step wrote out a PNG (4-view layout) and a STEP file when I ran cargo run, so dimension mistakes and shape glitches showed up right away. What I ended up with was one Solid with thread, double-face chamfer, and lead-in chamfer all per spec.

0. Project setup

Cargo.toml:

[package]
name = "nut"
version = "0.1.0"
edition = "2021"

[dependencies]
cadrum = "0.8.1"

cadrum fetches OpenCASCADE at build time, so on Windows the first build had me waiting a while. The second run was fast because the cache kicked in.

Step 1: one cube

I wanted to confirm that writing code actually got a solid onto the screen, so I just placed a single Solid::cube.

use cadrum::Solid;

fn main() -> Result<(), cadrum::Error> {
    let cube: Solid = Solid::cube(10.0, 10.0, 10.0).color("orange");

    cube.write_multiview_png(&mut std::fs::File::create("step1.png").unwrap())?;
    Solid::write_step([&cube], &mut std::fs::File::create("step1.step").unwrap())?;
    Ok(())
}

cargo run to execute.

write_multiview_png packed isometric, front, top, and right views into one PNG, with a scale bar and view-axis icons. While I was iterating on dimensions, it turned out to be faster than STEP. The write_step output I opened in FreeCAD just to sanity-check.

Step 2: extrude a hexagon

The nut's outline is a hex prism, so I built a hexagon profile and extruded it along Z.

For an M2 nut, ISO 4032 gave me width-across-flats s = 4.0 mm and thickness m = 1.6 mm. The distance from center to a vertex (circumscribed radius) came out to s / √3.

use cadrum::{DVec3, Edge, Solid};
use std::f64::consts::TAU;

fn main() -> Result<(), cadrum::Error> {
    let s = 4.0;
    let m = 1.6;
    let r_circum = s / 3f64.sqrt();

    let hex_pts: Vec<DVec3> = (0..6)
        .map(|i| {
            let a = i as f64 * TAU / 6.0;
            DVec3::new(r_circum * a.cos(), r_circum * a.sin(), 0.0)
        })
        .collect();
    let hex_profile = Edge::polygon(&hex_pts)?;

    let body: Solid = Solid::extrude(&hex_profile, DVec3::Z * m)?.color("orange");

    body.write_multiview_png(&mut std::fs::File::create("step2.png").unwrap())?;
    Solid::write_step([&body], &mut std::fs::File::create("step2.step").unwrap())?;
    Ok(())
}

Passing an array of vertices to Edge::polygon returned a closed polygonal wire. Handing that to Solid::extrude(profile, DVec3::Z * m) let me give direction and length as a single vector.

Step 3: drill the hole

I needed a threaded hole through the middle, so I made a cylinder and subtracted it.

cadrum overloads + / - / * between &Solid for union, difference, and intersection. The return type is Result<Solid, _>, so I chained with ?.

use cadrum::{DVec3, Edge, Solid};
use std::f64::consts::TAU;

fn main() -> Result<(), cadrum::Error> {
    let r = 1.0;                              // M2 nominal radius (major Ø2.0)
    let pitch = 0.4;                          // M2 pitch
    let h = 3f64.sqrt() / 2.0 * pitch;        // ISO 68-1 fundamental triangle height
    let s = 4.0;
    let m = 1.6;

    let r_circum = s / 3f64.sqrt();
    let r_minor = r - h * 6.0 / 8.0;          // minor radius (= thread-cutter shaft radius)

    let hex_pts: Vec<DVec3> = (0..6)
        .map(|i| {
            let a = i as f64 * TAU / 6.0;
            DVec3::new(r_circum * a.cos(), r_circum * a.sin(), 0.0)
        })
        .collect();
    let body = Solid::extrude(&Edge::polygon(&hex_pts)?, DVec3::Z * m)?;
    let bore = Solid::cylinder(r_minor, DVec3::Z, m + 0.4).translate(DVec3::Z * -0.2);

    let part: Solid = (&body - &bore)?.color("orange");

    part.write_multiview_png(&mut std::fs::File::create("step3.png").unwrap())?;
    Solid::write_step([&part], &mut std::fs::File::create("step3.step").unwrap())?;
    Ok(())
}

At first I set the hole length exactly to m, and the coplanar boolean at the top and bottom faces left a paper-thin shell. Bumping it to m + 0.4 so it pokes out 0.2 mm on each side cleaned that up.

I also went back and forth on the formula for r_minor. The ISO minor radius itself is r - h * 5/8, but using that left a thin wall after the thread cutter was subtracted later. I wanted it to match the thread-cutter shaft radius, so I went with r - h * 6/8.

Step 4: double-face chamfer

Looking at a real ISO 4032 nut from above, the outline came out to a regular 12-gon. It's the corners of the hexagon getting sliced off by a flat plane.

      ___      ←  this "corner sliced at an angle" is the chamfer
     /   \
    /     \
    \     /
     \___/

I first reached for the chamfer_edges API, but it only rounds edges and doesn't give the flat facets the spec calls for. The most direct option turned out to be subtracting half_space 12 times — 6 vertices × top/bottom.

use cadrum::{DVec3, Edge, Solid};
use std::f64::consts::TAU;

fn main() -> Result<(), cadrum::Error> {
    let r = 1.0;
    let pitch = 0.4;
    let h = 3f64.sqrt() / 2.0 * pitch;
    let s = 4.0;
    let m = 1.6;

    let r_apothem = s / 2.0;                       // inscribed radius
    let r_circum = s / 3f64.sqrt();
    let r_minor = r - h * 6.0 / 8.0;

    let cham_angle = 30f64.to_radians();           // ISO 4032 maximum
    let r_cham_reach = r_apothem - 0.1;
    let cham_outer_h = (r_circum - r_cham_reach) * cham_angle.tan();

    let hex_pts: Vec<DVec3> = (0..6)
        .map(|i| {
            let a = i as f64 * TAU / 6.0;
            DVec3::new(r_circum * a.cos(), r_circum * a.sin(), 0.0)
        })
        .collect();
    let mut body = Solid::extrude(&Edge::polygon(&hex_pts)?, DVec3::Z * m)?;

    let nr = cham_angle.sin();
    let nz = cham_angle.cos();
    for i in 0..6 {
        let theta = i as f64 * TAU / 6.0;
        let p_corner = DVec3::new(r_circum * theta.cos(), r_circum * theta.sin(), 0.0);
        let n_radial = DVec3::new(nr * theta.cos(), nr * theta.sin(), 0.0);
        body = (&body - &Solid::half_space(
            p_corner + DVec3::Z * (m - cham_outer_h),
            n_radial + DVec3::Z * nz,
        ))?;
        body = (&body - &Solid::half_space(
            p_corner + DVec3::Z * cham_outer_h,
            n_radial - DVec3::Z * nz,
        ))?;
    }

    let bore = Solid::cylinder(r_minor, DVec3::Z, m + 0.4).translate(DVec3::Z * -0.2);
    let part: Solid = (&body - &bore)?.color("orange");

    part.write_multiview_png(&mut std::fs::File::create("step4.png").unwrap())?;
    Solid::write_step([&part], &mut std::fs::File::create("step4.step").unwrap())?;
    Ok(())
}

Solid::half_space(origin, normal) is an infinite solid occupying the side the normal points to; subtracting it removes everything on that side. I used 12 planes, each passing through one of the vertical corner edges, tilted up or down 30° from horizontal.

Initially I had r_cham_reach = r_apothem, sitting exactly on the inscribed circle. In the 4-view, the chamfer width looked noticeably narrower than a conical cut would. A flat plane doesn't reach the middle of each face — it only shaves the corner — so it removes less material than a cone at the same reach. Pulling the reach in by 0.1 mm balanced the look (rule of thumb for M2).

The chamfer-height formula is Δr · tan(angle). I had cot instead of tan once and the result looked like 60°, which someone pointed out.

Step 5: lead-in chamfer

The top and bottom openings of the bore needed a taper — the part that helps a bolt enter.

I wanted to add a conical frustum to each end of the straight cylinder, so I used Solid::cone(r1, r2, axis, h). Even with r1 < r2 it produces a flared frustum without complaint.

use cadrum::{DVec3, Edge, Solid};
use std::f64::consts::TAU;

fn main() -> Result<(), cadrum::Error> {
    let r = 1.0;
    let pitch = 0.4;
    let h = 3f64.sqrt() / 2.0 * pitch;
    let s = 4.0;
    let m = 1.6;

    let r_apothem = s / 2.0;
    let r_circum = s / 3f64.sqrt();
    let r_minor = r - h * 6.0 / 8.0;

    let cham_angle = 30f64.to_radians();
    let r_cham_reach = r_apothem - 0.1;
    let cham_outer_h = (r_circum - r_cham_reach) * cham_angle.tan();

    let r_lead = r;
    let cham_lead_h = 0.20;

    let hex_pts: Vec<DVec3> = (0..6)
        .map(|i| {
            let a = i as f64 * TAU / 6.0;
            DVec3::new(r_circum * a.cos(), r_circum * a.sin(), 0.0)
        })
        .collect();
    let mut body = Solid::extrude(&Edge::polygon(&hex_pts)?, DVec3::Z * m)?;

    let nr = cham_angle.sin();
    let nz = cham_angle.cos();
    for i in 0..6 {
        let theta = i as f64 * TAU / 6.0;
        let p_corner = DVec3::new(r_circum * theta.cos(), r_circum * theta.sin(), 0.0);
        let n_radial = DVec3::new(nr * theta.cos(), nr * theta.sin(), 0.0);
        body = (&body - &Solid::half_space(
            p_corner + DVec3::Z * (m - cham_outer_h),
            n_radial + DVec3::Z * nz,
        ))?;
        body = (&body - &Solid::half_space(
            p_corner + DVec3::Z * cham_outer_h,
            n_radial - DVec3::Z * nz,
        ))?;
    }

    let main_bore  = Solid::cylinder(r_minor, DVec3::Z, m + 0.4)
        .translate(DVec3::Z * -0.2);
    let top_flare  = Solid::cone(r_minor, r_lead, DVec3::Z, cham_lead_h)
        .translate(DVec3::Z * (m - cham_lead_h));
    let bot_flare  = Solid::cone(r_minor, r_lead, -DVec3::Z, cham_lead_h)
        .translate(DVec3::Z * cham_lead_h);

    // union the three pieces into one cutter and subtract once
    let bore_cutter = (&(&main_bore + &top_flare)? + &bot_flare)?;
    let part: Solid = (&body - &bore_cutter)?.color("orange");

    part.write_multiview_png(&mut std::fs::File::create("step5.png").unwrap())?;
    Solid::write_step([&part], &mut std::fs::File::create("step5.step").unwrap())?;
    Ok(())
}

At first I subtracted the bore, top flare, and bottom flare in three separate - calls. The coplanar edges tripped up the boolean engine occasionally. Unioning the three with + into a single cutter and subtracting once made it steady.

For Solid::cone, r1 is the radius at the origin and r2 is at axis * h; passing -DVec3::Z as the axis gives a cone pointing downward.

Step 6: internal thread

Building an ISO 68-1 metric thread from scratch looked like a chore, but framing it as "build the male thread and subtract it from the bore" made it tractable. Same construction as cadrum's own 07_sweep.rs.

The thread cutter combines three pieces:

A triangle swept along a helix — the raw thread fin.
A shaft cylinder (minor diameter) — fills between fins into a continuous shaft.
A crest cylinder (slightly below the major radius) — clips the triangle tips into a flat crest.

use cadrum::{DVec3, Edge, ProfileOrient, Solid, Wire};
use std::f64::consts::TAU;

fn build_m2_hex_nut() -> Result<Solid, cadrum::Error> {
    let r = 1.0;
    let pitch = 0.4;
    let h = 3f64.sqrt() / 2.0 * pitch;
    let s = 4.0;
    let m = 1.6;

    let r_apothem = s / 2.0;
    let r_circum = s / 3f64.sqrt();
    let r_minor = r - h * 6.0 / 8.0;

    let cham_angle = 30f64.to_radians();
    let r_cham_reach = r_apothem - 0.1;
    let cham_outer_h = (r_circum - r_cham_reach) * cham_angle.tan();

    let r_lead = r;
    let cham_lead_h = 0.20;

    // 1. Hex prism
    let hex_pts: Vec<DVec3> = (0..6)
        .map(|i| {
            let a = i as f64 * TAU / 6.0;
            DVec3::new(r_circum * a.cos(), r_circum * a.sin(), 0.0)
        })
        .collect();
    let mut body = Solid::extrude(&Edge::polygon(&hex_pts)?, DVec3::Z * m)?;

    // 2. Double-face chamfer (12 half-space cuts)
    let nr = cham_angle.sin();
    let nz = cham_angle.cos();
    for i in 0..6 {
        let theta = i as f64 * TAU / 6.0;
        let p_corner = DVec3::new(r_circum * theta.cos(), r_circum * theta.sin(), 0.0);
        let n_radial = DVec3::new(nr * theta.cos(), nr * theta.sin(), 0.0);
        body = (&body - &Solid::half_space(
            p_corner + DVec3::Z * (m - cham_outer_h),
            n_radial + DVec3::Z * nz,
        ))?;
        body = (&body - &Solid::half_space(
            p_corner + DVec3::Z * cham_outer_h,
            n_radial - DVec3::Z * nz,
        ))?;
    }
    let body = body;

    // 3. Bore + lead-in chamfer (union once, subtract once)
    let main_bore  = Solid::cylinder(r_minor, DVec3::Z, m + 0.4)
        .translate(DVec3::Z * -0.2);
    let top_flare  = Solid::cone(r_minor, r_lead, DVec3::Z, cham_lead_h)
        .translate(DVec3::Z * (m - cham_lead_h));
    let bot_flare  = Solid::cone(r_minor, r_lead, -DVec3::Z, cham_lead_h)
        .translate(DVec3::Z * cham_lead_h);
    let bore_cutter = (&(&main_bore + &top_flare)? + &bot_flare)?;
    let body = (&body - &bore_cutter)?;

    // 4. Internal thread
    let thread_h = m + 0.4;
    let helix = Edge::helix(r - h, pitch, thread_h, DVec3::Z, DVec3::X)?;

    // ISO 68-1 fundamental triangle (base on the helix, apex pointing outward)
    let tri = Edge::polygon(&[
        DVec3::new(0.0, -pitch / 2.0, 0.0),
        DVec3::new(h, 0.0, 0.0),
        DVec3::new(0.0,  pitch / 2.0, 0.0),
    ])?;
    let tri = tri
        .align_z(helix.start_tangent(), helix.start_point())
        .translate(helix.start_point());

    let thread = Solid::sweep(&tri, &[helix], ProfileOrient::Up(DVec3::Z))?;
    let shaft  = Solid::cylinder(r - h * 6.0 / 8.0, DVec3::Z, thread_h);
    let crest  = Solid::cylinder(r - h / 8.0,       DVec3::Z, thread_h);

    // (thread ∪ shaft) ∩ crest = a shaft with fins whose tips have been clipped
    let cutter = (&(&thread + &shaft)? * &crest)?.translate(DVec3::Z * -0.2);

    let nut = (&body - &cutter)?;
    Ok(nut.color("orange"))
}

fn main() -> Result<(), cadrum::Error> {
    let nut: Solid = build_m2_hex_nut()?;
    nut.write_multiview_png(&mut std::fs::File::create("step6.png").unwrap())?;
    Solid::write_step([&nut], &mut std::fs::File::create("step6.step").unwrap())?;
    Ok(())
}

The first time I forgot align_z, the triangle stayed tilted as it traveled along the helix and the thread came out wavy. Calling Wire::align_z(tangent, point) to align the profile's Z axis with the helix tangent kept the same orientation all the way around.

ProfileOrient::Up(DVec3::Z) on Solid::sweep is the "keep the profile pointed Z-up while traversing the spine" mode. That one tripped me up on the first try too.

The final * &crest is the intersection that clips the triangle tips into a flat crest. &a + &b for union, &a - &b for difference, &a * &b for intersection — the consistency made it easy to revisit the code later.

Final screen shots with Fusion 360.

cross section

APIs that came up

API	Use
`Solid::cube` / `cylinder` / `cone` / `sphere`	Primitives
`Edge::polygon` / `Edge::helix`	Profiles and spines
`Solid::extrude(profile, dir)`	Profile + straight line → solid
`Solid::sweep(profile, spine, orient)`	Profile + curve → solid
`Solid::half_space(origin, normal)`	Infinite half-space (chamfers, splits)
`&a + &b` / `&a - &b` / `&a * &b`	Union / difference / intersection
`Wire::align_z(tangent, point)`	Orient the profile
`Solid::write_step` / `write_multiview_png`	Output

This was enough to make it all the way through to the thread. When I changed let r = 1.0; to 2.0 and set s = 7.0; m = 3.2;, an ISO 4032 M4 nut came out as-is, so parameterizing the dimensions paid off.

Next I'll pair it with an M2 bolt and try assembly output via Solid::write_step([&nut, &bolt], ...).

DEV Community: Satoshi Misumi