Two ways to add hardwareCopy Anchor Link

• Model a device opens the device modeler. It is the easiest way to add a device you own: it builds the entry, and its 3D model, from measurements and a photo.
• New part opens the catalog editor, described here. Use it for anything else (shelves, trays, mounts, brackets, panels, racks) or when you want full control over an entry's definition.

Both buttons are at the top of the catalog. You need to be signed in.

The catalog editorCopy Anchor Link

The editor at /catalog/new has four parts:

• New device: the quick way in. Give a Name, a Namespace (your handle), a Description, and the Width, Depth and Height in mm. This fills in the definition for a box-shaped device that stands on shelves and trays. The id is shown below the form, made from the namespace and the name.
• Definition: the entry as JSON. Edit it directly for anything the quick form doesn't cover, or paste a whole entry. The card's title says valid, or how many issues there are, and each issue is listed with the field it is about.
• Preview: the entry in 3D with its default values, updated as you type.
• Model file: upload a GLB or STL to draw the part with (contributors only; see Model files).

Save draft keeps the draft in your namespace. Submit for review saves it and sends it for review in one go. Both are available once the definition is valid. To change a saved draft later, use Edit on its row on the entry's page. See Entries and revisions.

A worked exampleCopy Anchor Link

A printed 1U tray for a 10″ rack, holding one mini PC:

{
    "id": "alice/mini-pc-tray",
    "rev": 1,
    "kind": "part",
    "name": "Mini PC tray (1U)",
    "category": "tray",
    "params": [{ "key": "depth", "label": "Depth", "kind": "length", "default": 160, "min": 80, "max": 220 }],
    "derived": {
        "units": 1,
        "faceH": { "expr": "U19 - 1.25" },
        "devH": { "expr": "on.deck.count > 0 ? on.deck.h : 0" }
    },
    "envelope": { "w": 250, "d": { "expr": "depth" }, "h": { "expr": "faceH" } },
    "plugs": [
        {
            "id": "ears",
            "provides": "rail/10in/eia",
            "frame": { "at": [125, 3, 0] },
            "occupies": { "kind": "linear", "span": { "expr": "max(1, round(units * U19 / host.pitch))" } }
        }
    ],
    "sockets": [
        {
            "id": "deck",
            "label": "Deck",
            "accepts": [{ "iface": "surface/flat" }],
            "frame": { "at": [18, 3.6, 3] },
            "shape": { "kind": "surface", "w": 214, "d": { "expr": "depth - 6" } },
            "capacity": 1
        }
    ],
    "geometry": {
        "kind": "generator",
        "id": "core/faceplate-tray@1",
        "args": { "faceH": { "expr": "faceH" }, "plateD": { "expr": "depth" } }
    },
    "constraints": [
        {
            "id": "height",
            "level": "error",
            "title": "Device fits under the next tray",
            "when": { "expr": "on.deck.count > 0" },
            "assert": { "expr": "devH + 3 <= faceH" },
            "message": "{fixed(devH, 1)} mm device in a {fixed(faceH, 1)} mm (1U) tray",
            "blocksFabrication": true
        }
    ],
    "fabrication": { "method": "fdm", "material": { "default": "PETG" } },
    "license": "CC-BY-SA-4.0",
    "attribution": [{ "name": "alice", "role": "author" }]
}

What each part of it does:

• The plug ears says the tray mounts on 10″ EIA rails. Its frame is the point that lands on the rails' socket: the middle of the faceplate, 3 mm back. Its span uses the host's pitch, so it takes one position on a whole-U rack and two on the half-U RackMate T0.
• The socket deck accepts anything that stands on its feet (surface/flat). Devices dropped on it are placed by x and y in millimetres, and can be centred across it.
• derived values are worked out once per part in a project, and anything below can read them. on.deck.h is the height of whatever sits on the deck, or 0 when it is empty.
• The constraint shows up in the project's checks. With blocksFabrication, a failing check holds back the STL export until the user overrides it.
• geometry draws the tray with one of the app's built-in generators. Without geometry, a part is drawn as its envelope box.

Entry referenceCopy Anchor Link

When you save, you are added to attribution as a contributor if you aren't there already.

Sockets and plugsCopy Anchor Link

A part's plug fits another part's socket when the plug's interface id matches one of the socket's accepts patterns. A pattern ending in /* matches any id that begins with it: rail/10in/* accepts rail/10in/eia.

A socket has a frame (where it is on its part), a shape and the interfaces it accepts. The shapes are:

• linear: positions along an axis (pitch, count, origin0). Rails are linear, running up the rack. A plug's occupies.span says how many positions it takes, and overlaps are reported.
• surface: a w × d area. Parts on it are placed by x and y in mm.
• grid: nx × ny cells at pitchX and pitchY (pegboards, hole grids).
• point: exactly one place.

capacity limits how many parts a socket takes. An accept may add a where expression, for example to accept 19″ parts only when the rack's standard is 19in.

The interfaces in use today:

Two parts should fit only when they really do. If your part is mechanically different from what an interface describes, don't reuse that interface.

Racks that are only a model fileCopy Anchor Link

A rack can be drawn entirely by an uploaded GLB or STL. Give the entry an envelope and declare its rail socket yourself: the rails' frame sits on their centre line, just in front of the flanges, at the bottom of U1. The entry cbnsndwch/rack-19in-12u-mesh is an example to copy.

ExpressionsCopy Anchor Link

Wherever a number, a true/false value or a text is allowed, you can write an expression instead, as { "expr": "…" }. Text fields (title, message, detail) take expressions in curly-brace holes, like the message in the example above.

• Operators: + - * / %, comparisons, && || !, a ? b : c, and text in single quotes.
• Functions: min, max, abs, floor, ceil, round(x[, decimals]), clamp(x, lo, hi), sqrt, sin, cos, tan and atan2 (in degrees), hypot, near(a, b, tol), fixed(x, decimals) (as text), and ulabel(pos, perU) (a rail position as a U label).
• Constants: U19 (44.45 mm, one rack unit) and PI.
• Names:
  • a bare name is the part's own param, derived value, exposed value, envelope size (w, d, h) or name;
  • parent.x is the enclosing assembly, root.x the project's top part, and host.x the part whose socket this one is mounted on;
  • child.<id>.x reads a child of an assembly (the first one, when it is repeated);
  • on.<socket>.x reads the first part on a socket, or 0 when it is empty;
  • on.<socket>.count, top, used, overlaps, tallest and n.<category> summarise a socket (tallest is the height of the tallest part on it);
  • mate.pos is this part's position on its socket.

A mistake in an expression doesn't break a project. It shows up in the project's Problems card, naming the entry and the field it came from. Loops between values are reported the same way.

Printable partsCopy Anchor Link

A part whose fabrication names a printable generator can be exported as an STL from a project. The printable generators are built into the app, so you can use the ones that exist but not add your own. See Exports and printing.

Model filesCopy Anchor Link

A model file draws a part from a 3D file instead of a generator or a box. Uploading one needs contributor access.

• Formats: GLB (binary glTF) or STL. glTF is read Y-up with the front facing +Z; STL is read Z-up, in millimetres.
• Size: up to 15 MB.
• Scale: files come in any unit, so Scale the model to fit the part's size is on by default. It scales the model evenly to fit the entry's envelope, centred and standing on its floor.

In the Model file section of the catalog editor, choose the file, then fill in where it comes from:

Tick I may share this file under this licence, and the credits above are complete, then Upload and attach. The file becomes the entry's geometry. Save the draft to keep it.

Only upload files you may share under one of those licences. For anything else, link to the page it is on (in the entry's description, for example) instead of uploading it.

The same file uploaded twice is stored once. Upload your own file again to correct its licence or credits. If someone else uploaded it first, their upload and credits are used.

Each model file's licence and credits appear on the entries that use it and on the Credits page. See Licences and credits.

ListingsCopy Anchor Link

Listings say where to get a part: online shops and physical stores, each with a dated price and stock report. They feed the BOM & quote. Anyone can see them on an entry's Where to get it card; adding them needs contributor access.

To add one, fill in the form at the bottom of Where to get it:

• Online shop or Physical store, and the shop or store's name.
• For a shop, the product page (required). For a store, its address or city (required), and optionally its page.
• Optionally a price with its three-letter currency (such as USD or EUR), the pack size (items per purchase), and the stock: in stock, few left or out of stock.

Then Add listing. Later, contributors can add a New price or report the stock on any listing. Prices and stock reports are dated, and a price older than 90 days is marked as stale.

Checklist before submittingCopy Anchor Link

• Dimensions come from a datasheet, a drawing or calipers. Say which in the description, or in a parameter's hint.
• The interfaces you use describe how the part really mounts.
• The part behaves in a project: it mounts, its checks read sensibly when they pass and when they fail, and it doesn't collide with its neighbours when it shouldn't. Your draft works in your own projects, so try it there first.
• Model files are yours to share, or carry an allowed licence with full credits. Otherwise link to them instead of uploading.

LimitsCopy Anchor Link

• An entry's definition can be up to 128 KB.
• You can make up to 120 catalog changes (saving, submitting, deleting) in 10 minutes.
• Contributors can upload up to 30 model files an hour.