fastener - parametric threaded fasteners

Many mechanical designs will contain threaded fasteners of some kind, either in a threaded hole or threaded screws or bolts holding two or more parts together. The fastener sub-package provides a set of classes that create many different types of nuts, screws and washers - as follows:

Here is a list of the classes (and fastener types) provided:

See Extending the fastener sub-package for guidance on how to easily add new sizes or entirely new types of fasteners.

The following example creates a variety of different sized fasteners:

from build123d import *
from bd_warehouse.fastener import HexNut, SocketHeadCapScrew, SetScrew

nut = HexNut(size="M3-0.5", fastener_type="iso4032")
setscrew = SetScrew(size="M6-1", fastener_type="iso4026",length=10 * MM)
capscrew = SocketHeadCapScrew(size="#6-32", fastener_type="asme_b18.3", length=(1/2) * IN)

Both metric and imperial sized standard fasteners are directly supported by the fastener sub-package although the majority of the fasteners currently implemented are metric.

Many of the fastener standards provide ranges for some of the dimensions - for example a minimum and maximum head diameter. This sub-package generally uses the maximum sizes when a range is available in-order to ensure clearance between a fastener and another part won’t be compromised by a physical part that is within specification but larger than the CAD model.

Threaded parts are complex for CAD systems to create and significantly increase the storage requirements thus making the system slow and difficult to use. To minimize these requirements all of the fastener classes have a simple boolean parameter that when True doesn’t create actual threads at all. Such simple parts have the same overall dimensions and such that they can be used to check for fitment without dramatically impacting performance.

All of the fasteners default to right-handed thread but each of them provide a hand string parameter which can either be "right" or "left".

The following sections describe each of the provided classes.

Nut

As the base class of all other nut and bolt classes, all of the derived nut classes share the same interface as follows:

class Nut(size: str, fastener_type: str, hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Parametric Nut

Base Class used to create standard threaded nuts

Parameters:

  • size (str) – standard sizes - e.g. “M6-1”

  • fastener_type (str) – type identifier - e.g. “iso4032”

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

Raises:

  • ValueError – invalid size, must be formatted as size-pitch or size-TPI

  • ValueError – invalid fastener_type

  • ValueError – invalid hand, must be one of ‘left’ or ‘right’

  • ValueError – invalid size

Each nut instance creates a set of instance variables that provide the CAD object as well as valuable parameters, as follows (values intended for internal use are not shown):

hole_locations: list[Location]

custom holes locations

property info

Return identifying information

property nut_thickness

maximum thickness of the nut

classmethod select_by_size(size: str) → dict[source]

Return a dictionary of list of fastener types of this size

classmethod sizes(fastener_type: str) → list[str][source]

Return a list of the nut sizes for the given type

classmethod types() → set[str][source]

Return a set of the nut types

Nut Selection

As there are many classes and types of nuts to select from, the Nut class provides some methods that can help find the correct nut for your application. As a reminder, to find the subclasses of the Nut class, use __subclasses__():

>>> Nut.__subclasses__()
[<class 'bd_warehouse.fastener.DomedCapNut'>, ...]

>>> HexNut.types()
{'iso4033', 'iso4032', 'iso4035'}

>>> HexNut.sizes("iso4033")
['M1.6-0.35', 'M1.8-0.35', 'M2-0.4', 'M2.5-0.45', 'M3-0.45', 'M3.5-0.6', 'M4-0.7', 'M5-0.8', 'M6-1', 'M8-1.25', 'M10-1.5', 'M12-1.75', 'M14-2', 'M16-2', 'M18-2.5', 'M20-2.5', 'M22-2.5', 'M24-3', 'M27-3', 'M30-3.5', 'M33-3.5', 'M36-4', 'M39-4', 'M42-4.5', 'M45-4.5', 'M48-5', 'M52-5']

>>> Nut.select_by_size("M6-1")
{<class 'bd_warehouse.fastener.DomedCapNut'>: ['din1587'], <class 'bd_warehouse.fastener.HexNut'>: ['iso4035', 'iso4032', 'iso4033'], <class 'bd_warehouse.fastener.HexNutWithFlange'>: ['din1665'], <class 'bd_warehouse.fastener.UnchamferedHexagonNut'>: ['iso4036'], <class 'bd_warehouse.fastener.SquareNut'>: ['din557']}

Derived Nut Classes

The following is a list of the current nut classes derived from the base Nut class. Also listed is the type for each of these derived classes where the type refers to a standard that defines the nut parameters. All derived nuts inherit the same API as the base Nut class.

Detailed information about any of the nut types can be readily found on the internet from manufacture’s websites or from the standard document itself.

Note that a HeatSetNut can only be placed with an InsertHole (see the Custom Holes section of more information). Also note that the size of a HeatSetNut includes a length component like “-Standard” or “-Short” but this depends on the type. Use the sizes method to see the valid values.

>>> HeatSetNut.sizes("McMaster-Carr")
['M2-0.4-Short', 'M2-0.4-Standard', 'M3-0.5-Short', 'M3-0.5-Standard', 'M4-0.7-Short', 'M4-0.7-Standard', 'M5-0.8-Short', 'M5-0.8-Standard']

Screw

As the base class of all other screw and bolt classes, all of the derived screw classes share the same interface as follows:

class Screw(size: str, length: float, fastener_type: str, hand: ~typing.Literal['right', 'left'] | None = 'right', simple: bool | None = True, socket_clearance: float | None = 6, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Parametric Screw

Base class for a set of threaded screws or bolts

Parameters:

  • size (str) – standard sizes - e.g. “M6-1”

  • length (float) – distance from base of head to tip of thread

  • fastener_type (str) – type identifier - e.g. “iso4014”

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • socket_clearance (float, optional) – gap around screw with no recess (e.g. hex head) which allows a socket wrench to be inserted. Defaults to 6mm.

Raises:

  • ValueError – invalid size, must be formatted as size-pitch or size-TPI

  • ValueError – invalid fastener_type

  • ValueError – invalid hand, must be one of ‘left’ or ‘right’

  • ValueError – invalid size

The following method helps with hole creation:

Screw Selection

As there are many classes and types of screws to select from, the Screw class provides some methods that can help find the correct screw for your application. As a reminder, to find the subclasses of the Screw class, use __subclasses__():

>>> Screw.__subclasses__()
[<class 'bd_warehouse.fastener.ButtonHeadScrew'>, ...]

>>> CounterSunkScrew.types()
{'iso14582', 'iso10642', 'iso14581', 'iso2009', 'iso7046'}

>>> CounterSunkScrew.sizes("iso7046")
['M1.6-0.35', 'M2-0.4', 'M2.5-0.45', 'M3-0.5', 'M3.5-0.6', 'M4-0.7', 'M5-0.8', 'M6-1', 'M8-1.25', 'M10-1.5']

  • select_by_size(size:str) : (dict{class:[type,…],} - e.g.:

>>> Screw.select_by_size("M6-1")
{<class 'bd_warehouse.fastener.ButtonHeadScrew'>: ['iso7380_1'], <class 'bd_warehouse.fastener.ButtonHeadWithCollarScrew'>: ['iso7380_2'], ...}

To see if a given screw type has screws in the length you are looking for, each screw class provides a dictionary of available lengths, as follows:

>>> CounterSunkScrew.nominal_length_range["iso7046"]
[3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0]

During instantiation of a screw any value of length may be used; however, only a subset of the above nominal_length_range is valid for any given screw size. The valid sub-range is given with the nominal_lengths property as follows:

>>> screw = CounterSunkScrew(fastener_type="iso7046",size="M6-1",length=12 * MM)
>>> screw.nominal_lengths
[8.0, 10.0, 12.0, 14.0, 16.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0]

Derived Screw Classes

The following is a list of the current screw classes derived from the base Screw class. Also listed is the type for each of these derived classes where the type refers to a standard that defines the screw parameters. All derived screws inherit the same API as the base Screw class.

Detailed information about any of the screw types can be readily found on the internet from manufacture’s websites or from the standard document itself.

Washer

As the base class of all other washer and bolt classes, all of the derived washer classes share the same interface as follows:

class Washer(size: str, fastener_type: str, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Parametric Washer

Base class used to create standard washers

Parameters:

  • size (str) – standard sizes - e.g. “M6”

  • fastener_type (str) – type identifier - e.g. “iso4032”

Raises:

  • ValueError – invalid fastener_type

  • ValueError – invalid size

Each washer instance creates a set of properties that provide the Solid CAD object as well as valuable parameters, as follows (values intended for internal use are not shown):

classmethod sizes(fastener_type: str) → list[str][source]

Return a list of the washer sizes for the given type

classmethod types() → list[str][source]

Return a set of the washer types

Washer Selection

As there are many classes and types of washers to select from, the Washer class provides some methods that can help find the correct washer for your application. As a reminder, to find the subclasses of the Washer class, use __subclasses__():

>>> Washer.__subclasses__()
[<class 'bd_warehouse.fastener.PlainWasher'>, <class 'bd_warehouse.fastener.ChamferedWasher'>, <class 'bd_warehouse.fastener.CheeseHeadWasher'>]

Here is a summary of the class methods:

>>> PlainWasher.types()
{'iso7091', 'iso7089', 'iso7093', 'iso7094'}

>>> PlainWasher.sizes("iso7091")
['M1.6', 'M1.7', 'M2', 'M2.3', 'M2.5', 'M2.6', 'M3', 'M3.5', 'M4', 'M5', 'M6', 'M7', 'M8', 'M10', 'M12', 'M14', 'M16', 'M18', 'M20', 'M22', 'M24', 'M26', 'M27', 'M28', 'M30', 'M32', 'M33', 'M35', 'M36']

>>> Washer.select_by_size("M6")
{<class 'bd_warehouse.fastener.PlainWasher'>: ['iso7094', 'iso7093', 'iso7089', 'iso7091'], <class 'bd_warehouse.fastener.ChamferedWasher'>: ['iso7090'], <class 'bd_warehouse.fastener.CheeseHeadWasher'>: ['iso7092']}

Derived Washer Classes

The following is a list of the current washer classes derived from the base Washer class. Also listed is the type for each of these derived classes where the type refers to a standard that defines the washer parameters. All derived washers inherit the same API as the base Washer class.

Detailed information about any of the washer types can be readily found on the internet from manufacture’s websites or from the standard document itself.

Custom Holes

When designing parts with build123d a common operation is to place holes appropriate to a specific fastener into the part. This operation is optimized with bd_warehouse by the following four custom hole objects:

class ClearanceHole(fastener: ~fastener.Nut | ~fastener.Screw, fit: ~typing.Literal['Close', 'Normal', 'Loose'] = 'Normal', depth: float | None = None, counter_sunk: bool = True, captive_nut: bool = False, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), mode: ~build123d.build_enums.Mode = <Mode.SUBTRACT>)[source]

Part Object: ClearanceHole

A clearance hole is a hole that is drilled through one of two (or more) parts to be assembled together with a screw or bolt. The diameter of the clearance hole is larger than the diameter of the screw or bolt so that it can pass through freely without engaging the threads. The purpose of a clearance hole is to ensure that the screw or bolt can be tightened into a threaded hole on another part without being obstructed by the part it passes through. This allows the head of the screw or bolt to clamp the parts together.

Parameters:

  • fastener (Union[Nut, Screw]) – A nut or screw instance

  • fit (Optional[Literal["Close", "Normal", "Loose"]], optional) – Control hole diameter. Defaults to “Normal”.

  • depth (float, optional) – hole depth - None implies through part. Defaults to None.

  • counter_sunk (bool, optional) – Is the fastener countersunk into the part?. Defaults to True.

  • captive_nut (bool, optional) – Is rotation of the nut disabled?. Defaults to False.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • mode (Mode, optional) – combination mode. Defaults to Mode.SUBTRACT.

Raises:

  • ValueError – Use InsertHole for HeatSetNut

  • ValueError – Invalid nut given

  • ValueError – No depth provided

class InsertHole(fastener: ~fastener.HeatSetNut, fit: ~typing.Literal['Close', 'Normal', 'Loose'] = 'Normal', depth: float | None = None, manufacturing_compensation: float = 0.0, mode: ~build123d.build_enums.Mode = <Mode.SUBTRACT>)[source]

Part Object: InsertHole

An insert hole is precisely sized to accommodate a heat-set nut, which is embedded into the base component. This process creates a robust connection with the base material, offering a durable metal threaded interface for the fastener. Heat-set nuts are particularly favored for use with 3D-printed objects, as they ensure strong and reliable connections between components, enhancing the structural integrity of the assembled parts.

Parameters:

  • fastener (Union[Nut, Screw]) – A nut or screw instance

  • fit (Optional[Literal["Close", "Normal", "Loose"]], optional) – Control hole diameter. Defaults to “Normal”.

  • depth (float, optional) – hole depth - None implies through part. Defaults to None.

  • manufacturing_compensation (float, optional) – used to compensate for over-extrusion of 3D printers. A value of 0.2mm will reduce the radius of an external thread by 0.2mm (and increase the radius of an internal thread) such that the resulting 3D printed part matches the target dimensions. Defaults to 0.0.

  • mode (Mode, optional) – combination mode. Defaults to Mode.SUBTRACT.

Raises:

  • ValueError – Use InsertHole for HeatSetNut

  • ValueError – No depth provided

class TapHole(fastener: ~fastener.Nut | ~fastener.Screw, material: ~typing.Literal['Soft', 'Hard'] = 'Soft', fit: ~typing.Literal['Close', 'Normal', 'Loose'] = 'Normal', depth: float | None = None, counter_sunk: bool = True, mode: ~build123d.build_enums.Mode = <Mode.SUBTRACT>)[source]

Part Object: TapHole

A tap hole is precisely drilled through a component, sized optimally for a subsequent operation where a tap is employed to cut threads into the material. The diameter of this pre-drilled hole is critical and is influenced by the specifications of the fastener that will be threaded into it, as well as the properties of the base material. This preparatory step ensures that the final tapped hole accurately accommodates the intended fastener, providing a secure and reliable fit.

Parameters:

  • fastener (Union[Nut, Screw]) – A nut or screw instance

  • material (Literal["Soft", "Hard"], optional) – Determines tap hole size. Defaults to “Soft”.

  • fit (Optional[Literal["Close", "Normal", "Loose"]], optional) – Control hole diameter for a countersunk fastener head. Defaults to “Normal”.

  • depth (float, optional) – hole depth - None implies through part. Defaults to None.

  • counter_sunk (bool, optional) – Is the fastener countersunk into the part?. Defaults to True.

  • mode (Mode, optional) – combination mode. Defaults to Mode.SUBTRACT.

Raises:

  • ValueError – Use InsertHole for HeatSetNut

  • ValueError – No depth provided

class ThreadedHole(fastener: ~fastener.Nut | ~fastener.Screw, material: ~typing.Literal['Soft', 'Hard'] = 'Soft', fit: ~typing.Literal['Close', 'Normal', 'Loose'] = 'Normal', depth: float | None = None, counter_sunk: bool = True, simple: bool = True, mode: ~build123d.build_enums.Mode = <Mode.SUBTRACT>)[source]

Part Object: ThreadedHole

A threaded hole refers to a hole that has been provided with internal threads, either through cutting (tapping) or forming, to allow a bolt or screw to be screwed into it. Threaded holes are used in a wide range of applications where secure fastening is required. They can be found in various sizes and thread patterns to match the corresponding screws or bolts.

Parameters:

  • fastener (Union[Nut, Screw]) – A nut or screw instance

  • material (Literal["Soft", "Hard"], optional) – Determines tap hole size. Defaults to “Soft”.

  • fit (Optional[Literal["Close", "Normal", "Loose"]], optional) – Control hole diameter. Defaults to “Normal”.

  • depth (float, optional) – hole depth - None implies through part. Defaults to None.

  • counter_sunk (bool, optional) – Is the fastener countersunk into the part?. Defaults to True.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • mode (Mode, optional) – combination mode. Defaults to Mode.SUBTRACT.

Raises:

  • ValueError – Use InsertHole for HeatSetNut

  • ValueError – No depth provided

The APIs for these holes are very similar. The fit parameter is used for clearance hole dimensions and to calculate the gap around the head of a countersunk screw. The material parameter controls the size of the tap hole as they differ as a function of the material the part is made of. For clearance and tap holes, depth values of None are treated as thru holes. The threaded hole method requires that depth be specified as a consequence of how the thread is constructed.

These methods use data provided by a fastener instance (either a Nut or a Screw) to both create the appropriate hole (possibly countersunk) in your part as well as add the location of the holes to the fastener’s hole_locations attribute to ease the creation of assemblies with both the base parts and fasteners.

For example, let’s build the parametric bearing pillow block:

import copy

from bd_warehouse.bearing import PressFitHole, SingleRowDeepGrooveBallBearing
from bd_warehouse.fastener import ClearanceHole, SocketHeadCapScrew
from build123d import *
from ocp_vscode import show

# Dimensions in the default unit of MM
height, width, thickness, padding, fillet_radius = 30, 50, 10, 12, 2

# Create the screw & bearing
cap_screw = SocketHeadCapScrew(size="M2-0.4", length=16, simple=False)
skate_bearing = SingleRowDeepGrooveBallBearing(size="M8-22-7")

# Create the pillow block
with BuildPart() as pillow_block:
    with BuildSketch():
        RectangleRounded(width, height, fillet_radius)
    extrude(amount=thickness)
    with Locations((0, 0, thickness)):  # On the top
        PressFitHole(bearing=skate_bearing, interference=0.025 * MM)
        with GridLocations(width - padding, height - padding, 2, 2):
            ClearanceHole(fastener=cap_screw)

pillow_block.part.color = Color("teal")

# Create an assembly of all the positioned parts
pillow_block_assembly = Compound(
    children=[pillow_block.part, skate_bearing.moved(skate_bearing.hole_locations[0])]
    + [copy.copy(cap_screw).moved(l) for l in cap_screw.hole_locations]
)
show(pillow_block_assembly)

Which results in:

pillow_block

Note the following benefits:

  • screw and bearing dimensions aren’t required,

  • the screw is created during instantiation of the SocketHeadCapScrew class without the user knowing any of its dimensions,

  • the ClearanceHole object only requires the fastener thus the user need not provide hole dimensions.

  • the assembly contains both the part and copies of the fastener thus avoiding the overhead of many fasteners in the design.

Not only were the appropriate holes for the bearing and M2-0.4 screws created but an assembly was created to store all of the parts in this project all without having to research the dimensions of the parts.

Note: In this example the simple=False parameter creates accurate threads on each of the screws which significantly increases the complexity of the model. The default of simple is True which models the thread as a simple cylinder which is sufficient for most applications without the performance cost of accurate threads.

The data used in the creation of these holes is available via three instance methods:

>>> screw = CounterSunkScrew(fastener_type="iso7046", size="M6-1", length=10)
>>> screw.clearance_hole_diameters
{'Close': 6.4, 'Normal': 6.6, 'Loose': 7.0}

>>> screw.clearance_drill_sizes
{'Close': '6.4', 'Normal': '6.6', 'Loose': '7'}
>>> screw.tap_hole_diameters
{'Soft': 5.0, 'Hard': 5.4}
>>> screw.tap_drill_sizes
{'Soft': '5', 'Hard': '5.4'}

Note that with imperial sized holes (e.g. 7/16), the drill sizes could be a fractional size (e.g. 25/64) or a numbered or lettered size (e.g. U).

Captive Nuts

The ClearanceHole method has a captive_nut parameter that when used with a hex or square nut will create a hole that captures the nut such that it can’t spin. Here is an example:

import cadquery as cq
from cq_warehouse.fastener import HexNut, SquareNut
import cq_warehouse.extensions

hex_nut = HexNut(size="M6-1", fastener_type="iso4033")
square_nut = SquareNut(size="M6-1", fastener_type="din557")
test_assembly = cq.Assembly()
block = (
    cq.Workplane("XY")
    .box(50, 50, 10)
    .faces(">Z")
    .workplane()
    .pushPoints([(-12.5, 0)])
    .clearanceHole(
        fastener=hex_nut, fit="Loose", captiveNut=True, baseAssembly=test_assembly
    )
    .pushPoints([(+12.5, 0)])
    .clearanceHole(fastener=square_nut, captiveNut=True, baseAssembly=test_assembly)
)
test_assembly.add(block, color=cq.Color("tan"))

if "show_object" in locals():
    show_object(test_assembly, name="test_assembly")

Which results in:

captive_nuts

The space around the nuts is controlled by the fit parameter.

Extending the fastener sub-package

The fastener sub-package has been designed to be extended in the following two ways:

Alternate Sizes

As mentioned previously, the data used to guide the creation of fastener objects is derived from csv files found in the same place as the source code. One can add to the set of standard sized fasteners by inserting appropriate data into the tables. There is a table for each fastener class; an example of the ‘socket_head_cap_parameters.csv’ is below:

Size

iso4762:dk

iso4762:k

…

asme_b18.3:dk

asme_b18.3:k

asme_b18.3:s

M2-0.4

3.98

2

M2.5-0.45

4.68

2.5

0.096

0.06

0.05

M3-0.5

5.68

3

0.118

0.073

1/16

…

0.118

0.073

1/16

#0-80

0.14

0.086

5/64

#1-64

#1-72

#2-56

The first row must contain a ‘Size’ and a set of ‘{fastener_type}:{parameter}’ values. The parameters are taken from the ISO standards where ‘k’ represents the head height of a screw head, ‘dk’ is represents the head diameter, etc. Refer to the appropriate document for a complete description. The fastener ‘Size’ field has the format ‘M{thread major diameter}-{thread pitch}’ for metric fasteners or either ‘#{guage}-{TPI}’ or ‘{fractional major diameter}-{TPI}’ for imperial fasteners (TPI refers to Threads Per Inch). All the data for imperial fasteners must be entered as inch dimensions while metric data is in millimeters.

There is also a ‘nominal_screw_lengths.csv’ file that contains a list of all the lengths supported by the standard, as follows:

Screw_Type

Unit

Nominal_Sizes

din931

mm

30,35,40,45,50,55,60,…

…

The ‘short’ and ‘long’ values from the first table (not shown) control the minimum and maximum values in the nominal length ranges for each screw.

New Fastener Types

The base/derived class structure was designed to allow the creation of new fastener types/classes. For new fastener classes a 2D drawing of one half of the fastener profile is required. If the fastener has a non circular plan (e.g. a hex or a square) a 2D drawing of the plan is required. If the fastener contains a flange and a plan, a 2D profile of the flange is required. If these profiles or plans are present, the base class will use them to build the fastener. The Abstract Base Class technology ensures derived classes can’t be created with missing components.

Reference

class DomedCapNut(size: str, fastener_type: ~typing.Literal['din1587'] = 'din1587', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Domed Cap Nut

DIN 1587 domed cap nuts, also known as acorn nuts, feature a high, rounded, closed-end top. These nuts are typically used to provide a finished appearance while also protecting exposed bolt threads from damage or corrosion. The dome prevents the entry of dirt and moisture, making them suitable for applications where hygiene, safety, or aesthetics are important. Domed cap nuts are often found in furniture, machinery, automotive, and architectural applications.

These nuts are tightened like standard hex nuts but offer the added benefit of thread protection and a smoother exterior that reduces the risk of snagging or injury.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • fastener_type (Literal["din1587"], optional) – Defaults to “din1587”. din1587 Hexagon domed cap nuts

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class HeatSetNut(size: str, fastener_type: ~typing.Literal['McMaster-Carr', 'Hilitchi'] = 'McMaster-Carr', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Heat Set Nut

Heat set insert nuts are specially designed threaded inserts used in thermoplastics to provide durable, reusable threads in 3D printed or injection-molded parts. These inserts are installed by heating them—typically with a soldering iron—and pressing them into a pre-formed hole in the plastic. As the insert heats the surrounding plastic, it melts slightly and flows into the knurled or slotted features of the insert, forming a strong mechanical bond upon cooling.

Heat set nuts are ideal for applications where threaded fasteners are frequently assembled and disassembled, helping to prevent wear and stripping in plastic components. They are widely used in prototyping, enclosures, robotics, and other applications where lightweight, modular designs are needed.

Parameters:

  • size (str) – nut size, e.g. M5-0.8-Standard

  • fastener_type (str) – standard or manufacturer that defines the nut [“McMaster-Carr”]

  • hand (Literal["right", "left"], optional) – direction of thread. Defaults to “right”.

  • simple (bool) – omit the thread from the nut. Defaults to True.

Variables:

fill_factor (float) – Fraction of insert hole filled with heatset nut

class HexNut(size: str, fastener_type: ~typing.Literal['iso4032', 'iso4033', 'iso4035'] = 'iso4032', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Hex Nut

Hex nuts are the most commonly used type of fastening nut, featuring a six-sided profile that provides a strong grip and easy installation with standard tools. They are used in conjunction with bolts, screws, and other externally threaded fasteners to secure components in mechanical assemblies.

ISO 4032, ISO 4033, and ISO 4035 define different variants of metric hex nuts: - ISO 4032 specifies a regular height hex nut with a standard width across flats. - ISO 4033 defines a heavy series hex nut, typically used for larger or more heavily loaded assemblies. - ISO 4035 specifies a thin (jam) nut, used where space is limited or as a locknut against a standard nut.

These nuts are widely used across industries including automotive, aerospace, machinery, and construction. They are available in various grades and finishes to suit different strength, corrosion resistance, and environmental requirements.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • fastener_type (Literal["iso4032", "iso4033", "iso4035"], optional) – Defaults to “iso4032”. iso4032 Hexagon nuts, Style 1 iso4033 Hexagon nuts, Style 2 iso4035 Hexagon thin nuts, chamfered

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class HexNutWithFlange(size: str, fastener_type: ~typing.Literal['din1665'] = 'din1665', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Hex Nut With Flange

A hex nut with flange combines a standard six-sided nut with an integrated flange at the base, which acts like a built-in washer. This flange helps distribute the clamping load over a larger surface area, reducing surface pressure and the risk of damage to softer materials. It also improves resistance to loosening due to vibration by increasing friction at the mating surface.

DIN 1665 specifies metric hex flange nuts used in general-purpose and structural applications. These nuts are often used in automotive, machinery, and assembly applications where ease of use, improved load distribution, and vibration resistance are desired. The flanged base eliminates the need for a separate washer in many cases, simplifying assembly and reducing part count.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • fastener_type (Literal["din1665"], optional) – Defaults to “din1665”. din1665 Hexagon nuts with flange

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class UnchamferedHexagonNut(size: str, fastener_type: ~typing.Literal['iso4036'] = 'iso4036', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Unchamfered Hexagon Nut

ISO 4036 defines a thin, unchamfered hexagon nut, typically used in non-critical applications or where space and weight constraints are a priority. Unlike standard hex nuts, these nuts lack a chamfered edge and are manufactured with reduced height, which makes them suitable for low-stress assemblies, locking applications (e.g., as a jam nut), or secondary fastening positions.

Due to their minimal height and absence of chamfers, they are generally not intended for high-load structural use. Instead, they are ideal for internal assemblies, compact enclosures, or when used in combination with standard nuts to resist loosening under vibration. ISO 4036 nuts are most often found in light mechanical assemblies and electronics hardware.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • fastener_type (Literal["iso4036"], optional) – Defaults to “iso4036”. iso4036 Hexagon thin nuts, unchamfered

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class SquareNut(size: str, fastener_type: ~typing.Literal['din557'] = 'din557', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Square Nut

Square nuts, as defined by DIN 557, are four-sided nuts commonly used in older machinery, woodworking, and applications where a flat bearing surface and greater resistance to loosening are beneficial. Their larger surface area compared to hex nuts provides increased grip and load distribution, especially when used with flat washers or in slots.

DIN 557 specifies standard square nuts with a flat top and bottom and sharp or slightly chamfered corners. These nuts are well-suited for tightening by hand or with simple tools, and are often found in applications where ease of alignment or aesthetics are not critical. Their geometry makes them less prone to rounding and easier to weld or lock in place.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • fastener_type (Literal["din557"], optional) – Defaults to “din557”. din557 - Square Nuts

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class ButtonHeadScrew(size: str, length: float, fastener_type: ~typing.Literal['iso7380_1'] = 'iso7380_1', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Button Head Screw

ISO 7380-1 defines hexagon socket button head screws, characterized by a low-profile, rounded head and an internal hex drive. These screws are designed for applications requiring a smooth, finished appearance with moderate strength. The large head diameter provides a greater bearing surface, reducing the risk of pull-through and improving load distribution on softer materials.

Button head screws are commonly used in enclosures, furniture, robotics, and lightweight mechanical assemblies where aesthetics and compact form factor are important. The internal hex socket allows for easy installation with standard hex keys, and their shallow head height makes them well-suited for space-constrained applications. However, they are not intended for high-torque or high-strength applications due to their smaller head-to-shank transition area.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso7380_1"], optional) – Defaults to “iso7380_1”. iso7380_1 - Hexagon socket button head screws hand (Literal[“right”,”left”], optional): thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class ButtonHeadWithCollarScrew(size: str, length: float, fastener_type: ~typing.Literal['iso7380_2'] = 'iso7380_2', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Button Head With Collar Screw

ISO 7380-2 defines hexagon socket button head screws with an integrated collar or washer face beneath the head. This collar increases the bearing surface area, improving load distribution and reducing surface deformation when fastening into softer materials. Compared to standard button head screws (ISO 7380-1), the collar also adds stability and reduces the risk of loosening due to vibration.

These screws retain the low-profile, rounded aesthetic of button head designs while providing enhanced performance in critical applications. They are ideal for assemblies in robotics, consumer electronics, machinery panels, and enclosures where a smooth finish and added clamping force are needed. The internal hex drive allows for easy and secure installation using standard hex keys.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso7380_2"], optional) – Defaults to “iso7380_2”. iso7380_2 - Hexagon socket button head screws with collar

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class CheeseHeadScrew(size: str, length: float, fastener_type: ~typing.Literal['iso1207', 'iso7048', 'iso14580'] = 'iso7048', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Cheese Head Screw

Cheese head screws are cylindrical-head fasteners with vertical sides and a flat top, offering a clean, compact profile. The head has a smaller diameter and taller profile than pan or button head screws, providing a deep drive socket or slot for strong torque transmission. These screws are commonly used where head space is limited or where components are recessed into counterbores.

Multiple ISO standards define variations: - ISO 1207: Slotted cheese head machine screws for general applications. - ISO 7048: Cross-recessed (Phillips) cheese head screws. - ISO 14580: Hex socket cheese head screws, often used in precision assemblies.

Cheese head screws are widely used in electrical components, enclosures, and machinery where a tall head is acceptable but a compact footprint is desired. Their straight vertical sides also make them ideal for components that require precise guidance or centering in assembly features.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso1207", "iso7048", "iso14580"], optional) – Defaults to “iso7048”. iso1207 - Slotted cheese head screws iso7048 - Cross-recessed cheese head screws iso14580 - Hexalobular socket cheese head screws

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class CounterSunkScrew(size: str, length: float, fastener_type: ~typing.Literal['iso2009', 'iso7046', 'iso10642', 'iso14581', 'iso14582'] = 'iso10642', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

CounterSunk Screw

Countersunk screws are flat-head fasteners designed to sit flush with or below the surface of the material they are installed into. The conical underside of the head matches a countersunk hole, allowing for a clean finish and reduced interference in assembled products. These screws are used in applications where appearance, clearance, or aerodynamics are important, such as in enclosures, electronics, automotive panels, and structural components.

Multiple ISO standards define specific variations: - ISO 2009: Slotted countersunk head screws. - ISO 7046: Cross-recessed (Phillips) countersunk screws for general use. - ISO 10642: Hex socket countersunk screws, often used in machinery and precision equipment. - ISO 14581: Low-profile, cross-recessed countersunk screws for space-constrained applications. - ISO 14582: Hex socket, low-profile countersunk screws for compact, high-strength fastening.

The variety of head heights and drive types enables countersunk screws to meet the aesthetic, mechanical, and space requirements of a wide range of assemblies.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal[ "iso2009", "iso7046", "iso10642", "iso14581", "iso14582"], optional) – Defaults to “iso10642”. iso2009 - Slotted countersunk head screws iso7046 - Cross recessed countersunk flat head screws iso10642 - Hexagon socket countersunk head cap screws iso14581 - Hexalobular socket countersunk flat head screws iso14582 - Hexalobular socket countersunk flat head screws, high head

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class HexHeadScrew(size: str, length: float, fastener_type: ~typing.Literal['iso4014', 'iso4017'] = 'iso4014', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Hex Head Screw

Hex head screws, also referred to as hex bolts or hex cap screws, are externally threaded fasteners with a six-sided head designed for use with wrenches or sockets. They are widely used in construction, machinery, automotive, and industrial applications where strong, reliable bolted joints are required.

Two main ISO standards define their dimensional properties: - ISO 4014: Hex head screws with a partially threaded shank, typically used where shear strength is needed along the unthreaded portion. - ISO 4017: Fully threaded hex head screws, used for general-purpose fastening where full thread engagement is desired.

These screws are available in a range of material grades and finishes, and are often used with corresponding hex nuts and washers to ensure uniform clamping force and load distribution. Their standardized geometry ensures compatibility with automated assembly tools and industry-standard hardware.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso4014", "iso4017"], optional) – Defaults to “iso4014”. iso4014 - Hexagon head bolt iso4017 - Hexagon head screws

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class HexHeadWithFlangeScrew(size: str, length: float, fastener_type: ~typing.Literal['din1662', 'din1665'] = 'din1662', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Hex Head With Flange Screw

Hex head screws with flanges combine a standard hexagonal head with an integrated washer-like flange at the base. The flange increases the bearing surface area under the head, distributing clamping forces more evenly and reducing surface damage to the assembled material. This design also improves resistance to loosening caused by vibration, especially when used without a separate washer.

DIN 1662 and DIN 1665 define common types of flanged hex screws: - DIN 1662: Hex flange screws with a partially threaded shank. - DIN 1665: Hex flange screws that are fully threaded, offering continuous engagement over the entire shaft.

These screws are frequently used in automotive, structural, and industrial applications where secure fastening, reduced part count, and simplified assembly are important. The integrated flange simplifies the design and assembly process by eliminating the need for a separate washer while enhancing load distribution.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["din1662", "din1665"], optional) – Defaults to “din1662”. din1662 - Hexagon bolts with flange small series din1665 - Hexagon head bolts with flange

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class PanHeadScrew(size: str, length: float, fastener_type: ~typing.Literal['iso1580', 'iso14583', 'asme_b_18.6.3'] = 'iso14583', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Pan Head Screw

Pan head screws feature a broad, low-profile head with gently curved sides and a flat bearing surface underneath. This shape provides a large contact area, reducing the likelihood of damage to the fastened material and allowing for a clean, finished appearance. The rounded sides offer a smoother look than hex or cheese heads while still accommodating a variety of drive types.

Several standards define pan head screws: - ISO 1580: Slotted pan head machine screws for general mechanical use. - ISO 14583: Pan head screws with a hexalobular (Torx) drive for improved torque transfer and reduced cam-out. - ASME B18.6.3: The U.S. standard for slotted, cross-recessed (Phillips), or combination-drive pan head machine screws.

Pan head screws are commonly used in enclosures, electronics, mechanical assemblies, and applications where aesthetics, low head height, and easy access are important. Their wide head allows for secure fastening without requiring countersinking or additional washers.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso1580", "iso14583", "asme_b_18.6.3"], optional) – Defaults to “iso14583”. iso1580 - Slotted pan head screws iso14583 - Hexalobular socket pan head screws asme_b_18.6.3 - Type 1 Cross Recessed Pan Head Machine Screws

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class PanHeadWithCollarScrew(size: str, length: float, fastener_type: ~typing.Literal['din967'] = 'din967', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Pan Head With Collar Screw

DIN 967 defines a pan head screw with an integrated collar or washer-like flange beneath the head. The collar increases the bearing surface area, improving load distribution and reducing surface indentation on the clamped material. The pan head retains a low-profile, rounded appearance, while the collar eliminates the need for a separate washer in many applications.

These screws typically feature a slotted or cross-recessed (Phillips) drive and are widely used in automotive, appliance, and light mechanical assemblies where compactness, aesthetics, and vibration resistance are important. The combination of pan head geometry and an integral flange makes them especially useful when fastening to softer materials such as plastics or thin sheet metal.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["din967"], optional) – Defaults to “din967”. din967 - Cross recessed pan head screws with collar

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class RaisedCheeseHeadScrew(size: str, length: float, fastener_type: ~typing.Literal['iso7045'] = 'iso7045', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Raised Cheese Head Screw

ISO 7045 defines raised cheese head screws with a cylindrical, slightly domed head and a flat underside. These screws combine the deep drive engagement and tall profile of standard cheese head screws with a subtle domed surface for improved aesthetics and reduced edge sharpness. The result is a screw that offers high torque capability while maintaining a more refined appearance.

Raised cheese head screws are typically available with slotted or cross-recessed (Phillips) drives, and are used in mechanical assemblies, consumer electronics, and enclosures where clearance is limited but drive reliability is important. The tall head allows for secure tool engagement, while the rounded top helps reduce snagging and cosmetic impact in visible assemblies.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso7045"], optional) – Defaults to “iso7045”. iso7045 - Cross recessed raised cheese head screws

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class RaisedCounterSunkOvalHeadScrew(size: str, length: float, fastener_type: ~typing.Literal['iso2010', 'iso7047', 'iso14584'] = 'iso14584', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Raised CounterSunk Oval Head Screw

Raised countersunk screws—also known as oval head screws—feature a conical bearing surface like standard countersunk screws, but with a gently domed top. This combination provides a flush fit with a slightly protruding decorative finish, making them suitable for applications where appearance and smooth contours are important.

Multiple ISO standards define oval head screws with different drive types: - ISO 2010: Slotted raised countersunk head screws for general-purpose use. - ISO 7047: Cross-recessed (Phillips) version for improved alignment and automation. - ISO 14584: Hexalobular (Torx) drive version for high torque applications with reduced cam-out.

These screws are commonly used in electronics, appliance housings, mechanical assemblies, and consumer products where flush mounting is required but a low-profile dome provides a more refined look and reduced snagging.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso2010", "iso7047", "iso14584"], optional) – Defaults to “iso14584”. iso2010 - Slotted raised countersunk oval head screws iso7047 - Cross recessed raised countersunk head screws iso14584 - Hexalobular socket raised countersunk head screws

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class SetScrew(size: str, length: float, fastener_type: ~typing.Literal['iso4026'] = 'iso4026', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Set Screw

ISO 4026 defines set screws with a flat point and a hexagon socket drive. These screws are fully threaded and lack a head, allowing them to sit flush or recessed within a mating part. Set screws are primarily used to secure one component against another—most commonly to fix a rotating part such as a gear or pulley onto a shaft.

The flat point provides secure contact without damaging the mating surface, making it ideal for use in applications where frequent adjustments or disassembly may be required. Set screws are commonly used in mechanical assemblies, couplings, collars, and linkages where space is limited and unobtrusive fastening is essential.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso4026"], optional) – Defaults to “iso4026”. iso4026 - Hexagon socket set screws with flat point

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class SocketHeadCapScrew(size: str, length: float, fastener_type: ~typing.Literal['iso4762', 'asme_b18.3'] = 'iso4762', hand: ~typing.Literal['right', 'left'] = 'right', simple: bool = True, rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Socket Head Cap Screw

Socket head cap screws are high-strength fasteners with a cylindrical head and an internal hexagonal drive. Designed for use where external wrench clearance is limited, these screws are tightened with a hex key (Allen wrench) and provide excellent torque transfer and holding power. The tall head allows for deep socket engagement, reducing the risk of stripping.

  • ISO 4762 specifies metric socket head cap screws for general and precision mechanical use.

  • ASME B18.3 defines the inch-based counterpart, widely used in North American engineering standards.

Socket head cap screws are commonly used in machinery, robotics, automotive assemblies, and structural applications where compactness and reliability are important. Their strong clamping force and clean geometry make them ideal for pre-tapped holes and locations with tight access.

Parameters:

  • size (str) – size specification, e.g. “M6-1”

  • length (float) – screw length

  • fastener_type (Literal["iso4762","asme_b18.3"], optional) – Defaults to “iso4762”. iso4762 - Hexagon socket head cap screws asme_b18.3 - Imperial hexagon socket head cap screws

  • hand (Literal["right","left"], optional) – thread direction. Defaults to “right”.

  • simple (bool, optional) – simplify by not creating thread. Defaults to True.

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class PlainWasher(size: str, fastener_type: ~typing.Literal['iso7089', 'iso7091', 'iso7093', 'iso7094'], rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Plain Washer

Plain washers are flat, disc-shaped components used under the head of a screw or nut to distribute the clamping load and protect the mating surface from damage. They also help reduce surface deformation and prevent fasteners from loosening due to vibration or movement.

Several ISO standards define plain washers of different series: - ISO 7089: Normal series washers with standard outer diameter and thickness. - ISO 7091: Normal series washers with slightly tighter tolerances and more controlled flatness. - ISO 7093: Large series washers with greater outer diameter for use with oversized or slotted holes. - ISO 7094: Extra-large series washers, offering the greatest surface area and ideal for use with soft materials or wide clearances.

These washers are used in nearly all types of bolted assemblies across mechanical, structural, automotive, and industrial applications.

Parameters:

  • size (str) – size specification, e.g. “M6”

  • fastener_type (Literal["iso7089", "iso7091", "iso7093", "iso7094"]) – iso7089 - Plain washers, Form A iso7091 - Plain washers iso7093 - Plain washers — Large series iso7094 - Plain washers - Extra large series

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class ChamferedWasher(size: str, fastener_type: ~typing.Literal['iso7090'] = 'iso7090', rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Chamfered Washer

ISO 7090 defines chamfered washers, which are plain washers with a conical or beveled underside designed to match the chamfer on fasteners such as countersunk or chamfered-head bolts. The chamfer provides full surface contact between the washer and fastener head, improving load distribution and alignment, especially in high-stress or structural applications.

These washers help prevent damage to the mating surface by reducing point loading and ensuring even contact. They are typically used with screws or bolts that have a 120° chamfer under the head— such as ISO 7379 shoulder screws—or in assemblies requiring enhanced axial alignment and bearing surface support.

Chamfered washers are commonly found in heavy machinery, construction, tooling fixtures, and high-precision assemblies where joint integrity is critical.

Parameters:

  • size (str) – size specification, e.g. “M6”

  • fastener_type (Literal["iso7090"], optional) – Defaults to “iso7090”. iso7090 - Plain washers, Form B

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.

class CheeseHeadWasher(size: str, fastener_type: ~typing.Literal['iso7092'] = 'iso7092', rotation: ~build123d.geometry.Rotation | tuple[float, float, float] = (0, 0, 0), align: None | ~build123d.build_enums.Align | tuple[~build123d.build_enums.Align, ~build123d.build_enums.Align, ~build123d.build_enums.Align] = None, mode: ~build123d.build_enums.Mode = <Mode.ADD>)[source]

Cheese Head Washer

ISO 7092 defines plain washers specifically designed for use with cheese head screws. These washers have a reduced outer diameter and a thickness tailored to the narrow, cylindrical profile of cheese head fasteners, ensuring proper seating and load distribution under the head without protruding beyond its edges.

Cheese head washers help prevent surface damage, distribute clamping forces more evenly, and improve appearance in precision assemblies. Their compact size makes them ideal for use in electronics, instrumentation, and machine components where space is limited and a clean, flush appearance is desired.

These washers are especially useful when paired with ISO 1207 or ISO 14580 cheese head screws in counterbored holes or recessed applications.

Parameters:

  • size (str) – size specification, e.g. “M6”

  • fastener_type (Literal["iso7092"], optional) – Defaults to “iso7092”. iso7092 - Washers for cheese head screws

  • rotation (RotationLike, optional) – object rotation. Defaults to (0, 0, 0).

  • align (Union[None, Align, tuple[Align, Align, Align]], optional) – object alignment. Defaults to None.

  • mode (Mode, optional) – combination mode. Defaults to Mode.ADD.