.meb format specification
Status:
[x]ready — version 3.0.0
Normative document. Implementations must conform to it.
Glossary: 01-glossary.md. Data model: 02-data-model.md. Field reference: 04-field-reference.md.
1. File format
1.1 Extension and MIME type
| Property | Value |
|---|---|
| Extension | .meb |
| MIME type | application/vnd.meb+json |
| Encoding | UTF-8 without BOM |
1.2 Structure
A .meb file is a JSON document. The root is an object ({}). Arrays and primitive values as the root are not allowed.
An implementation MUST reject a file that:
- is not valid JSON,
- has a root other than an object,
- does not contain the
metafield.
1.3 Unknown fields
An implementation reading a file with a newer MINOR version within the same MAJOR MUST ignore fields it does not recognize instead of returning a critical error (see 05-versioning.md).
For files validated as exactly this version of the standard, the only normative vendor extension mechanism is fields prefixed with x_. A conformance validator for a specific version MAY reject other unknown fields.
2. Primitive types
| Type | Description |
|---|---|
string | UTF-8 character string |
number | JSON number (integer or floating-point) |
bool | true or false |
mm | Number in millimeters — type number, always > 0 unless stated otherwise |
degrees | Angle in degrees — type number, range depends on context |
id | Unique identifier — type string, non-empty, max 128 characters |
ref | Reference to the id of another object — type string |
datetime | Date and time in ISO 8601 format, e.g. "2025-03-15T14:30:00Z" |
A null value on an optional field is equivalent to the field being absent. An implementation MUST treat null and absent identically.
3. Conformance keywords
This document uses keywords with the following meaning:
| Keyword | Meaning |
|---|---|
| MUST / MUST NOT | Absolute requirement / prohibition |
| SHOULD / SHOULD NOT | Recommendation — deviation requires justification |
| MAY | Optional — the implementation's decision |
An implementation is conformant with this specification if it meets all requirements marked MUST / MUST NOT.
4. File root (MebFile)
The file root contains the following fields:
| Field | Type | Required | Description |
|---|---|---|---|
meta | object | yes | File metadata |
project | object | yes | Project data |
scene | array | yes | Scene graph — node tree, array of root nodes (§7) |
materials_catalog | array | yes | Material library |
edging_catalog | array | yes | Edge banding library |
drilling_catalog | array | yes | Drilling type library |
hardware_catalog | array | yes | Hardware library |
profiles | array | yes | Geometric profile catalog |
grain_groups | array | no | Grain continuity groups |
biscuit_catalog | array | no | Biscuit catalog (biscuit joints) |
meshes_catalog | array | no | Catalog of meshes for solids and hardware (§11.7) |
comments | array | no | Comments |
Required arrays MAY be empty ([]). Repeated keys at the same level are not allowed.
5. Metadata (meta)
The meta object describes the file as an artifact — not the project.
| Field | Type | Required | Description |
|---|---|---|---|
version | string | yes | Version of the .meb standard (semver), e.g. "3.0.0" |
created_at | datetime | yes | Date and time the file was created |
created_by | object | no | Source software |
checksum | string | no | Checksum (see §5.2) |
5.1 meta.created_by object
| Field | Type | Required | Description |
|---|---|---|---|
name | string | yes | Application name |
version | string | no | Application version |
5.2 Checksum
The meta.checksum field contains a SHA-256 checksum of the file contents, excluding the checksum field itself (and its value). A validating implementation SHOULD ignore the field before computing the checksum, without modifying the file structure.
Format: "sha256:<hex>", e.g. "sha256:a3f2...".
6. Project (project)
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Project identifier |
name | string | yes | Project name |
description | string | no | Free-form description |
has_3d | bool | no | true — the file contains 3D position data; false — no 3D data, spatial preview unavailable. An absent field is treated as true. |
client | object | no | Client data |
designer | object | no | Designer data |
6.1 client and designer objects
Both objects have an identical structure:
| Field | Type | Required | Description |
|---|---|---|---|
name | string | yes | Full name or company name |
email | string | no | Email address |
phone | string | no | Phone number |
company | string | no | Company name (for individuals) |
7. Scene graph (scene)
7.1 General principle
scene is a node tree — an array of root nodes. A node is a group (group), a panel (panel), a hardware item (hardware) or a solid (solid). Only a group has children (children); a panel, a hardware item and a solid are leaves. The tree maps the document tree of the design program one to one: a group in the program is a group in the file, a panel is a panel (3.0.0).
- Each node has a position and rotation relative to its parent (§14.3) — rotating a group rotates everything that stands in it.
- Panels, hardware and solids stand in any group and in the root — a countertop above a set of cabinets does not need an artificial cabinet.
- What a group is for production and rules is stated by its role (§7.4): a cabinet is a group with the role
"cabinet", while a drawer, a subassembly and a set are groups without a role, nested arbitrarily.
7.2 Node (node)
Fields common to all nodes:
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique node identifier across the whole file |
name | string | yes | Free-form label |
type | string | yes | "group", "panel", "hardware" or "solid" |
position | object | yes¹ | Position relative to the parent {x, y, z} in mm |
rotation | object | yes¹ | XYZ Euler rotation relative to the parent {x, y, z} in degrees |
production_id | string | no | Production number (see §7.5) |
comment_refs | array | no | List of id values from comments[] |
¹ position and rotation are absent from: a hardware item without a position (§12) and the nodes of a file without 3D data (project.has_3d: false, §6).
The position field contains three numbers {x, y, z} — each in mm. The rotation field contains three numbers {x, y, z} — each in degrees, in XYZ order; each angle SHOULD lie in the range (−180°, 180°] — a half turn as 180, never -180.
7.3 Group node (type: "group")
Additional fields:
| Field | Type | Required | Description |
|---|---|---|---|
role | string | no | Group role — "cabinet" (cabinet); absent — a plain group (§7.4) |
front | string | no | Front of the group in its coordinate system: "-Y" (default) | "+Y" | "-X" | "+X" (§14.2) |
children | array | yes | Child nodes: groups, panels, hardware and solids |
Every group has a front, not only a cabinet — a drawing of the front of a set or a drawer is a view from the front side of its coordinate system. The field is editable: a program whose group coordinate system has its front on a side other than -Y states that side here (§14.2).
7.4 Group role
The role states what a group is for production and rules. It is assigned to an existing group — five panels grouped into a drawer, three drawers grouped into a group with the cabinet role — and the group remains the same group, with the same children.
role | What the group is |
|---|---|
| absent | a plain group: drawer, subassembly, set, room |
"cabinet" | cabinet — the unit of production and of the production number (§7.5); its coordinate system determines the cabinet's production drawing (§14.2) |
Tree rules:
- There is no cabinet inside a cabinet at any depth — a group with the role
"cabinet"MUST NOT have a group with the role"cabinet"among its descendants, including through a drawer or a subassembly. - A node other than a group MUST NOT contain the
childrenfield.
A new role is a new field value (MINOR change, 05-versioning.md §4). A reading implementation MUST treat a role it does not know as a group without a role.
7.5 Production number (production_id)
production_id is an optional structural identifier assigned by the exporting software. Format: numeric segments separated by dots, e.g. "01.02.03". The number of segments corresponds to the depth in the tree.
Two nodes receive the same production_id at their level if they are structurally identical — i.e. they have equal values of all production-relevant fields (dimensions, material, machining, children), excluding position, rotation, name, id and comment_refs. Identical drawers therefore get one number.
Solids, as well as the position and geometry of hardware, do not belong to production and do not affect the production_id of any node. The hardware of a group is compared by hardware_ref and total quantity.
A number once assigned stays — an implementation that saves an object loaded from a .meb file (including from its own earlier export) SHOULD preserve its production_id; the identity and segment-count rules apply to the numbers it assigns itself.
The field is informational. A reading implementation MAY ignore it.
7.6 Solid node (type: "solid")
A solid is any geometry with a material — a wall, a floor, a ceiling, a column, a built-in massing volume, a household appliance, a decoration. The standard does not distinguish kinds of solids: the name is a free-form label, and whether the object concerns production is stated solely by the material (§11.1.1). A solid does not go to production — even when it has a furniture material.
Additional fields:
| Field | Type | Required | Description |
|---|---|---|---|
material_ref | ref | yes | Reference to materials_catalog[].id — appearance of the solid |
geometry | object | yes | Solid geometry (§7.6.1) |
A solid node is a leaf. It stands in the root or in any group — an oven and a sink in a built-in unit are children of the cabinet and travel together with it. The geometry object also describes the simplified geometry of a hardware item (§12).
7.6.1 Solid geometry (geometry)
| Field | Type | Required | Description |
|---|---|---|---|
type | string | yes | "extrusion" (outline with thickness), "mesh" (mesh) or "polyhedron" (polyhedron) |
outline | object | when extrusion | Outline — a path object (§10) with closed: true |
holes | array | no (only extrusion) | Holes — path objects with closed: true, lying inside the outline |
thickness | mm | when extrusion | Extrusion thickness |
mesh_ref | ref | when mesh | Reference to meshes_catalog[].id |
vertices | array | when polyhedron | Polyhedron vertices (§7.6.2) |
edges | array | when polyhedron | Polyhedron edges (§7.6.2) |
faces | array | when polyhedron | Polyhedron faces (§7.6.2) |
Outline with thickness (extrusion) is the same geometry as a panel: an outline in the XY plane of the solid's coordinate system, extruded from Z = 0 to Z = thickness (§14.5). A window or door opening is a hole in the wall outline, a sloped ceiling — an oblique segment of its outline. The segments line, arc and bezier have the meaning given in §10; the segment fields id and machined do not apply here.
Mesh (mesh) describes what an outline with thickness cannot express: a curved wall with a window, an irregular niche, a household appliance, a sink. A mesh is always embedded in the file, in meshes_catalog (§11.7); one mesh can serve many solids and hardware items.
Polyhedron (polyhedron) is a solid made of flat polygonal faces, as drawn by a program that models with edges and faces: a wall with a through window, a sloped ceiling, a niche, a room with its floor and walls in one solid (§7.6.2). A face is any polygon with holes, so a polyhedron is exact and does not need triangles. Every vertex, edge and face has an id that the program keeps between edits — the solid returns from the file to the program without loss.
7.6.2 Polyhedron (polyhedron)
Vertex (vertices[]):
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Vertex identifier, unique within the polyhedron |
x, y, z | number | yes | Position in the solid's coordinate system (§14.5), in mm |
Edge (edges[]):
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Edge identifier, unique within the polyhedron |
start | ref | yes | Start vertex — vertices[].id |
end | ref | yes | End vertex — vertices[].id, different from start |
fold | bool | no | Fold edge — created when a face stopped being flat and was folded into triangles; default false |
Face (faces[]):
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Face identifier, unique within the polyhedron |
loops | array | yes | Face loops: the first is the outline, the following ones — holes; each loop is an array of vertices[].id, min. 3 |
Rules:
- every two consecutive vertices of a loop — and the last with the first — are the ends of an edge from
edges. An edge belongs to any number of faces or to none: an edge without a face is a drawing line, without a surface, - the outline runs counterclockwise when looking at the face from the side of its normal, and the holes — clockwise, so the face always lies to the left of the loop direction. The normal of a face of a closed solid points outward, as in a mesh (§11.7),
- the vertices of a face lie in one plane; holes lie inside the outline and intersect neither the outline nor each other,
- a polyhedron MAY be open — a bare face without thickness, an edge without a face — and MAY consist of several disjoint pieces,
- an implementation drawing a polyhedron triangulates the faces itself; it MAY draw a fold edge thin or omit it.
8. Panel (panel)
A panel is a tree node (type: "panel", §7.2) — a leaf that stands in any group or in the root.
8.1 Identification fields
| Field | Type | Required | Description |
|---|---|---|---|
type | string | yes | "panel" |
id | id | yes | Unique node identifier across the whole file |
name | string | yes | Free-form label |
production_id | string | no | Production number (see §7.5) |
comment_refs | array | no | List of id values from comments[] |
8.2 Geometry and position
| Field | Type | Required | Description |
|---|---|---|---|
dimensions | object | yes | Panel dimensions |
position | object | yes | Position {x, y, z} relative to the parent (group or root), mm |
rotation | object | yes | XYZ Euler rotation {x, y, z}, degrees |
The dimensions object contains:
| Field | Type | Required | Description |
|---|---|---|---|
length | mm | yes | Finished length after edge banding (vertical axis in the cutting plan view; along_length direction) |
width | mm | yes | Finished width after edge banding (horizontal axis) |
thickness | mm | yes | Finished thickness after edge banding |
Dimensions are always the finished size after edge banding. Computing the raw size is up to the implementation (see §14.4).
8.3 Material and grain direction
| Field | Type | Required | Description |
|---|---|---|---|
material_ref | ref | yes | Reference to materials_catalog[].id |
grain | string | yes | Whether and in which direction the panel respects the material grain |
grain_group_ref | ref | no | Reference to grain_groups[].id |
Allowed values of grain: "along_length" | "along_width" | "none".
Grain hierarchy: material ↔ panel
Grain (texture) is a property of the material only — its existence and base direction are described by material.grain (see §11). The panel.grain field is subordinate to the material and decides whether a given panel respects the grain:
material.grain | panel.grain | Interpretation |
|---|---|---|
none | any | Material without grain → panel.grain ignored; rotation allowed; no texture |
≠ none | none | The panel does not respect the grain → rotation allowed; texture not drawn |
≠ none | along_length / along_width | The panel respects the grain in this direction → rotation locked (§15.5); texture drawn |
When material.grain = "none", the value of panel.grain SHOULD be "none" (it is ignored anyway).
8.4 Bending (bend)
The bend field is optional. Its presence means that the panel is bent cylindrically.
| Field | Type | Required | Description |
|---|---|---|---|
axis | string | yes | Bend axis: "width" or "length" |
radius | mm | yes | Arc radius |
radius_type | string | yes | Radius type: "inner" or "outer" |
angle | degrees | yes | Arc angle in degrees |
A panel can be bent along one axis only. Implementations that do not support bending MUST inform the user about the unknown geometry — they MUST NOT silently skip the field.
8.5 Edge banding (edging)
The edging field describes the edge banding of the four edges of the panel.
| Field | Type | Required | Description |
|---|---|---|---|
xL | object|null | no | Edge banding of the width edge at x=L (top) |
x0 | object|null | no | Edge banding of the width edge at x=0 (bottom) |
yW | object|null | no | Edge banding of the length edge at y=W (left) |
y0 | object|null | no | Edge banding of the length edge at y=0 (right) |
sequence | string | no | Which pair of edges is banded first ("width_first" | "length_first", default "width_first") |
Each edge object (xL, x0, yW, y0):
| Field | Type | Required | Description |
|---|---|---|---|
ref | ref | yes | Reference to edging_catalog[].id |
The sequence field (default "width_first") specifies which pair of opposite edges is banded first:
"width_first"— first the width edges (xL/x0), then the length edges (y0/yW)."length_first"— first the length edges (y0/yW), then the width edges (xL/x0).
The pair banded later covers the corners of the earlier pair. The model reflects the physical order on the edge bander (opposite edges banded in pairs) — which is why an arbitrary order of individual sides cannot be represented. The value applies regardless of which edges have edge banding.
8.5.1 Edge finish (edge_finish)
The edge_finish field (since 2.2.0) is optional and stands next to edging. It describes a panel edge that is not banded but finished on the board itself — sanded and/or chamfered. Typical case: compact boards (HPL) with a sanded edge and a 1×1 mm chamfer at the face and at the back.
| Field | Type | Required | Description |
|---|---|---|---|
xL | object|null | no | Finish of the width edge at x=L (top) |
x0 | object|null | no | Finish of the width edge at x=0 (bottom) |
yW | object|null | no | Finish of the length edge at y=W (left) |
y0 | object|null | no | Finish of the length edge at y=0 (right) |
Each edge object (xL, x0, yW, y0):
| Field | Type | Required | Description |
|---|---|---|---|
sanded | bool | yes | The edge surface is sanded |
chamfer | mm | yes | Size of the 45° chamfer made on both corners of the edge — at the face and at the back; 0 = no chamfer (value ≥ 0) |
chamfer: 1 means a 1 × 1 mm chamfer at 45° along the entire edge — one at the face, the other at the back.
The field describes the result — what the finished edge looks like — not the machine, the tool or the process (the same principle as for milling, §9.3). The production system decides with what and at which stage the edge is sanded and chamfered. The finish does not change the panel dimensions — dimensions remains the finished size (§8.2).
Meaning of the field's presence:
- no
edge_finishfield — the file says nothing about edge finishing; a reading implementation MAY apply its own default setting (e.g. one assigned to the material), - field present, edge
nullor omitted — that edge has no finish; an empty object{}explicitly means that no edge is finished.
An edge has either edge banding or a finish — non-null edging.{side} and edge_finish.{side} on the same edge are mutually exclusive. The chamfer MUST fit within the thickness: 2 × chamfer < dimensions.thickness (§15.8).
edge_finish is neither a surface finish nor a bevel:
finishes[](§8.6) are layers of material applied to a surface (veneer, laminate, lacquer) —edge_finishapplies nothing, it describes the machining of the board edge itself,bevels[](§9.1) is a structural angled cut that changes the shape of the panel — a 1 mm chamfer on an edge corner is a finish, not a bevel.
The field addresses the sides of the base rectangle, just like edging. The cut walls of an outline contour and of a hole cut-out are finished with the routing.edge_finish field (§9.3.2).
Example — 12 mm HPL compact countertop: three edges sanded with a 1×1 mm chamfer, edge yW (against the wall) without a finish, the sink cut-out finished the same way around its entire perimeter:
{
"id": "panel_blat_hpl",
"name": "Blat kompaktowy HPL",
"dimensions": { "length": 1200, "width": 600, "thickness": 12 },
"position": { "x": 0, "y": 0, "z": 0 },
"rotation": { "x": 0, "y": 0, "z": 0 },
"material_ref": "mat_hpl_12",
"grain": "none",
"edge_finish": {
"xL": { "sanded": true, "chamfer": 1 },
"x0": { "sanded": true, "chamfer": 1 },
"y0": { "sanded": true, "chamfer": 1 },
"yW": null
},
"operations": {
"routings": [
{
"type": "hole",
"path": {
"start": { "x": 400, "y": 150 },
"closed": true,
"segments": [
{ "type": "line", "end": { "x": 800, "y": 150 } },
{ "type": "line", "end": { "x": 800, "y": 450 } },
{ "type": "line", "end": { "x": 400, "y": 450 } },
{ "type": "line", "end": { "x": 400, "y": 150 } }
]
},
"edge_finish": { "walls": "all", "sanded": true, "chamfer": 1 }
}
]
}
}8.6 Surface finishes (finishes)
The finishes field is an optional array of finishes applied to the panel surfaces.
| Field | Type | Required | Description |
|---|---|---|---|
surface | string | yes | Coated surface (see below) |
material_ref | ref | yes | Reference to materials_catalog[].id |
order | number | yes | Order of application on the same surface (1 = first) |
comment_refs | array | no | List of id values from comments[] |
Allowed values of surface: "face_top" | "face_bottom" | "edge_xL" | "edge_x0" | "edge_y0" | "edge_yW".
One finish describes one surface. Multiple finishes on the same surface are processed in ascending order.
8.7 Layered composition (composite)
The composite field is optional. Its presence means that the panel is glued in production from thinner layers — e.g. a 36 mm panel glued from 2×18 mm. An absent field means a monolith (e.g. a 38 mm countertop), which is not split into components.
| Field | Type | Required | Description |
|---|---|---|---|
layers | array | yes | List of layers — min. 2 elements |
Layer object (layer):
| Field | Type | Required | Description |
|---|---|---|---|
order | integer | yes | Layer position: 1 = bottom / back, n = top / front |
material_ref | ref | yes | Reference to materials_catalog[].id |
thickness | mm | yes | Layer thickness |
Validation rules:
- The sum of the thicknesses of all layers MUST equal
panel.dimensions.thickness. - The
ordervalues MUST form a continuous sequence without repetitions (1, 2, …, n). - Each
material_refMUST point to an existing entry inmaterials_catalog[]of categoryboard.
The interpretation of CNC operations, edge banding and finishes on composite panels is up to the production system — the .meb format does not describe the assignment of operations to individual layers.
8.8 Operations (operations)
The operations field is an object containing lists of machining operations:
| Field | Type | Required | Description |
|---|---|---|---|
bevels | array | no | Angled cuts (bevels) |
drillings | array | no | Drillings |
routings | array | no | Milling operations |
An absent operations field is equivalent to an object with all lists empty.
9. Machining operations
All operation coordinates refer to the canonical panel orientation (see §14.1), regardless of the panel's rotation field.
9.1 Bevel (bevel)
| Field | Type | Required | Description |
|---|---|---|---|
edge_side | string | one of† | Base side: "xL" | "x0" | "yW" | "y0" |
on_segment | ref | one of† | id of a line segment of an outline/hole contour (see §9.2.2) |
from_face | string | yes | Starting plane: "top" | "bottom" |
angle | degrees | yes | Cut angle from the perpendicular (0° = straight, 45° = standard bevel) |
leave | mm | yes | Thickness of material left straight before the bevel, ≥ 0 |
depth | mm | no | Bevel depth — when omitted: depth = d − leave |
edging | object | no | Edge banding on the bevelled surface |
comment_refs | array | no | List of id values from comments[] |
† A bevel is addressed either by edge_side (a base side of the rectangle) or by on_segment (a contour segment) — exactly one of these modes.
leave = 0 means a bevel starting right at the edge of the from_face plane.
A bevel always covers the entire edge (the entire base side or the entire segment) — there are no start/end fields. Partial chamfering is done with a profiled slot (§9.3.1).
A bevel via on_segment is allowed only for segments of type line — a bevel is a straight cut (by a saw or a straight pass of a router bit). A curved edge (arc/bezier) is not chamfered with a bevel; profiled chamfering of a curve is done with a profiled slot (type: slot, §9.3.1). The scope of on_segment is as in §9.2.2: through segments of outline (machined) and hole.
When more than one bevel is defined on the same edge (edge_side or on_segment) and from the same from_face side, the depth field is required for each of them.
The edging object in a bevel:
| Field | Type | Required | Description |
|---|---|---|---|
ref | ref | yes | Reference to edging_catalog[].id |
9.2 Drilling (drilling)
| Field | Type | Required | Description |
|---|---|---|---|
drilling_ref | ref | yes | Reference to drilling_catalog[].id |
type | string | yes | "face" (face) or "edge" (edge) |
face | string | when type: face | "top" | "bottom" |
edge_side | string | when type: edge on a base side | "xL" | "x0" | "yW" | "y0" |
on_segment | ref | when type: edge on a contour | id of an outline or hole path segment (see §9.2.2) |
x | mm | when face; when edge_side: y0/yW | Position along the length (see §9.2.1) |
y | mm | when face; when edge_side: xL/x0 | Position along the width (see §9.2.1) |
s | mm | when on_segment | Distance along the contour segment from its start (see §9.2.2) |
z | mm | no (only type: edge) | Position across the thickness, from the face; default thickness/2. This is the position of the hole in the thickness, not the drilling depth — the depth comes from drilling_catalog (see §9.2.1) |
hardware_instance_ref | ref | no | id of the hardware item the drilling results from (§12.1) |
comment_refs | array | no | List of id values from comments[] |
An edge drilling (type: edge) is addressed either by edge_side (a base side of the rectangle) or by on_segment (a contour edge) — exactly one of these modes.
9.2.1 Drilling coordinate system
Canonical system (§14.1): x along the length (0..L, vertical), y along the width (0..W, horizontal — increases to the left), z across the thickness — depth from the face (face: top), z ∈ [0, thickness], z = 0 at the face, z = thickness at the back, default thickness/2. Face origin = bottom-right (x=0 at the bottom, y=0 on the right).
type: face—xfrom the bottom edge (along the length),yfrom the right edge (along the width).zdoes not apply — the drilling depth comes fromdrilling_catalog.type: edge,edge_side: y0oryW(length edges) —xis the position along the length (from the bottom);yis determined byedge_side(y0→y=0,yW→y=W) and is not given. Position of the hole in the thickness:z.type: edge,edge_side: xLorx0(width edges) —yis the position along the width (from the right);xis determined byedge_side(x0→x=0,xL→x=L) and is not given. Position in the thickness:z.
The position in the thickness is always in the z field, measured from the face regardless of the edge — neither of the x/y axes changes its meaning between edges any more. z is the position of the hole in the thickness, not the drilling depth (which comes from drilling_catalog). The drill entry direction follows from edge_side.
9.2.2 Drilling in a contour edge (on_segment)
When a panel has a non-axial edge created by a through cut — an oblique segment or an arc of the outline (routing type: outline) or the wall of a through cut-out (type: hole) — the edge cannot be addressed via edge_side: no x/y coordinate is constant, and the drilling direction rotates along the edge. Such a drilling is addressed parametrically along the contour segment:
on_segment— reference to theidof a segment in anoutlineorholepath; the segment MUST have anid(see §10).s— distance along this segment from its start point, in mm (arc length — works forline,arc,bezier);0 ≤ s ≤segment length.z— depth from the face as in §9.2.1 (defaultthickness/2); range[0, thickness], because the contour goes through the entire thickness.
The x/y position of the hole is determined from the segment geometry and is not given. The drilling direction (normal to the edge) follows from the segment geometry and the material side (path winding): for outline the material is inside the contour, for hole — outside it (on the panel side, not the cut-out side). The on_segment and edge_side modes are mutually exclusive.
Note: in outline the target of on_segment is usually a machined segment (a real cut that distinguishes the contour from the base rectangle); in hole every segment is a through wall, so the machined flag does not apply. pocket (non-through) is not supported by on_segment — its wall reaches only to depth, not through the entire thickness.
9.3 Milling (routing)
The .meb format describes only the resulting geometry of a milling operation — it does not describe the cutting tool, the cutting parameters or the CAM strategy. The standard distinguishes five geometric primitives:
| Field | Type | Required | Description |
|---|---|---|---|
type | string | yes | "slot" | "outline" | "hole" | "pocket" | "biscuit" |
finishes | array | no | Coatings on the milled surface |
hardware_instance_ref | ref | no | id of the hardware item the milling results from (§12.1) |
comment_refs | array | no | List of id values from comments[] |
9.3.1 Slot — swept slot (type: "slot")
A slot describes a sweep geometry: a constant cross-section moving along a trajectory. It covers slots on the face, slots/rebates on the edge, roundovers, profiled chamfers, slots for HDF back panels, cornices, etc.
A slot has two orthogonal axes:
- placement — where the trajectory runs:
surface(on the face, fieldpath) oredge(along an edge, fieldedge_sideoron_segment). The placement follows from the presence of fields —path(→ surface) oredge_side/on_segment(→ edge), exactly one mode. - section — how the cross-section is described:
simple(rectanglewidth×depth) orprofiled(full profileprofile_ref). Thesectionfield is required and explicit.
Common fields:
| Field | Type | Required | Description |
|---|---|---|---|
section | string | yes | "simple" | "profiled" |
face | string | yes | surface: machined face ("top" | "bottom"); edge: reference corner ("top" = from the face, "bottom" = from the back) |
Placement surface — trajectory on the face:
| Field | Type | Required | Description |
|---|---|---|---|
path | object | yes | Trajectory of the slot axis (see §10) |
Placement edge — trajectory along an edge:
| Field | Type | Required | Description |
|---|---|---|---|
edge_side | string | one of† | Base side: "xL" | "x0" | "yW" | "y0" |
on_segment | ref | one of† | id of an outline/hole contour segment (§9.2.2) |
start | mm | no‡ | Start along the edge/segment — default 0 |
end | mm | no‡ | End along the edge/segment — default to the end |
† Exactly one of edge_side / on_segment. ‡ start and end are given together or omitted together.
For edge_side, start/end is the coordinate along the edge counted from 0: for the length edges (y0/yW) — along the length from x=0; for the width edges (xL/x0) — along the width from y=0. For on_segment it is s (arc length) along the segment from its start. The scope of on_segment is as in §9.2.2 (through segments of outline/hole).
Section simple — rectangular cross-section:
| Field | Type | Required | Description |
|---|---|---|---|
width | mm | yes | Slot width (dimension transverse to the plunge direction) |
depth | mm | yes | Cut depth from the entry surface |
offset | mm | no | Offset of the cross-section from the reference line, tangential to the entry surface — default 0 |
For surface, offset shifts the rectangle sideways from the path axis (in the face plane); for edge — along the thickness from the face corner. At offset = 0 the surface cross-section is centered on the path axis (width/2 to each side), and the edge cross-section starts at the face ∩ edge corner.
Section profiled — full profile:
| Field | Type | Required | Description |
|---|---|---|---|
profile_ref | ref | yes | Reference to profiles[].id — the full cut cross-section |
In the profiled variant the profile defines the entire cut geometry (shape, width, depth, position). There is no width, depth or offset — any offset is baked into the profile itself (the profile has its own start, §11.5). The milling depth follows from the reach of the profile into the material (axis Y, §11.5.2). The profile MUST be open and anchored on the entry surface (§11.5.2, §15.7).
For the profile coordinate system and its orientation relative to the trajectory — see §11.5.2.
9.3.2 External outline (type: "outline")
Outline describes a through milling that changes the external outline of the panel. The path is a closed contour (closed: true) describing the finished shape of the panel; its orientation (winding) determines the material side, following the CAD convention. The operation always goes through the entire thickness — there is no depth or through field.
The dimensions field still describes the base rectangle (raw, for the cutting plan); the outline contour describes the shape after machining. The real machining is the difference between the contour and the base rectangle: segments that coincide with the sides of the rectangle are edges of the blank (no cut), and the segments that deviate from them are the actual milling.
The machined marker. A path segment may carry the "machined": true flag, meaning that it is a real cut (a difference vs. the rectangle). When no segment of the contour has an explicit flag, the implementation determines the machining geometrically — a segment not lying on the boundary of the dimensions rectangle is a cut. Thanks to this, the postprocessor (e.g. XCS) and pre_trim/edging operate only on the sections that are actually machined, not on the whole contour.
| Field | Type | Required | Description |
|---|---|---|---|
path | object | yes | Closed contour (closed: true) of the finished shape; cut segments marked machined |
edging | object | array | no | Edge banding on the cut walls (one entry or an array of entries — different materials) |
edge_finish | object | no | Finish of the cut walls without edge banding — sanding and chamfer (2.2.0) |
By default the cut wall is straight (a vertical through cut across the entire thickness). Profiling or chamfering the wall of a specific segment is done with a separate operation targeting that segment via on_segment: a profiled slot (§9.3.1) or a bevel (§9.1). The standard has no separate “wall profile” field.
The edging object (common to outline and hole):
| Field | Type | Required | Description |
|---|---|---|---|
ref | ref | yes | Reference to edging_catalog[].id |
walls | string|array | yes | "all" or an array of wall designations |
pre_trim | bool | no | Whether the edge bander pre-mills the edge by the edge band thickness before banding — default false |
The walls field indicates which cut walls are banded:
"all"— all real cut walls (foroutlinethemachinedsegments; forholethe entire perimeter).- an array — mixed items: base sides (
"xL","x0","yW","y0") and/or segmentids of the path (a reference tosegments[].id, §10). A segmentidaddresses a single non-axial wall (e.g. a specific oblique segment) when it cannot be indicated by a base side. A segment indicated byidMUST have anidand be a real cut.
pre_trim: true is allowed only for type: outline, when the machined (machined) section of the contour is a single straight segment (a line). The edge bander cannot pre-mill a curved or broken edge — therefore for machining made of arcs, curves or multiple segments, and for type: hole, pre_trim MUST remain false (or be omitted).
Array form (2.1.0). edging can be an array of { ref, walls, pre_trim } objects — different walls of the same contour banded with different materials (e.g. each oblique segment with a different edge band). Each entry has its own ref and its own walls list; the same wall MUST NOT appear in more than one entry. A single object is equivalent to a one-element array and remains valid.
Wall finish (edge_finish, 2.2.0). The edge_finish object (common to outline and hole) describes cut walls that are not banded but sanded and/or chamfered — the counterpart of panel.edge_finish (§8.5.1) for contour walls.
| Field | Type | Required | Description |
|---|---|---|---|
walls | string|array | yes | "all" or an array of wall designations — like edging.walls |
sanded | bool | yes | The walls are sanded |
chamfer | mm | yes | Size of the 45° chamfer on both corners of the wall — at the face and at the back; 0 = no chamfer (value ≥ 0) |
The walls field means the same as edging.walls: "all" — all real cut walls (for outline the machined segments, for hole the entire perimeter); an array — base sides and/or path segment ids. An absent edge_finish means, as for a panel, that the file says nothing about the finish of the walls; with the field present — walls outside walls are not finished. The same wall MUST NOT appear simultaneously in edging.walls (in any entry) and in edge_finish.walls, and the chamfer MUST fit within the thickness: 2 × chamfer < dimensions.thickness (§15.8). edge_finish applies only to outline and hole — slot, pocket and biscuit MUST NOT have this field.
9.3.3 Through cut-out (type: "hole")
Hole describes a through milling inside the panel — the path MUST lie entirely inside the dimensions rectangle, without touching its boundary. The operation always goes through the entire thickness — there is no depth or through field.
| Field | Type | Required | Description |
|---|---|---|---|
path | object | yes | Closed contour (closed: true) inside the panel |
edging | object | array | no | Edge banding on the cut-out walls (one entry or an array of entries) |
edge_finish | object | no | Finish of the cut-out walls without edge banding — sanding and chamfer (2.2.0) |
By default the cut-out wall is straight (a vertical through cut). Profiling/chamfering the wall of a segment — with a separate operation via on_segment (slot §9.3.1 or bevel §9.1).
The edging object — as for outline (above). The pre_trim field does not apply (the cut-out contour is not a straight edge) and MUST be false or omitted. The edge_finish object — as for outline (above).
9.3.4 Pocket (type: "pocket")
Pocket describes a non-through milling on the panel face — a recess to a specified depth. The path may lie anywhere (inside the rectangle or at its boundary) — this does not change the semantics: a pocket does not modify the external shape of the panel.
| Field | Type | Required | Description |
|---|---|---|---|
face | string | yes | "top" | "bottom" |
depth | mm | yes | Cut depth below the face |
path | object | yes | Pocket contour — MUST be closed (closed: true) |
A pocket has a flat bottom at depth depth and straight (vertical) walls. The standard has no pocket wall profile field. If any wall is to be profiled or chamfered, this is done with a separate slot (type: slot, placement: surface) with a path trajectory running along that edge — a second machining operation. (on_segment does not support pockets, because their wall is not a through wall, §9.2.2.)
A pocket does not support edge banding — pocket walls are not banded. Edge banding on milled walls applies only to the outline and hole types. The same applies to the wall finish (edge_finish).
9.3.5 Biscuit / lamella (type: "biscuit")
Biscuit describes a point milling for a biscuit (lamella) joint. The geometry follows from the size of the biscuit defined in the biscuit_catalog.
The x, y position describes the biscuit axis. This means that the biscuit_catalog[].thickness dimension is distributed symmetrically on both sides of the axis: for thickness: 4 the recess occupies 2 mm on each side of the axis.
The standard distinguishes two biscuit variants:
- Edge biscuit — milling done from the panel edge.
edge_side(a base side) oron_segment(a contour edge) is required, andfaceis forbidden. The position of the recess axis along the edge and the depthzfrom the face — the same system as for edge drilling (§9.2.1, §9.2.2): fory0/yWyou givex, forxL/x0—y, for a contour —on_segment+s; the depth of the axis in the thickness isz(defaultthickness/2). On the panel diagram the projection onto the face is a half-ellipse reachingwidth / 2into the panel, and the projection onto the edge is athickness × lengthrectangle. - Face biscuit — milling done from the panel face.
faceis required, andedge_side/on_segmentis forbidden. The axis position is described byx,y;anglespecifies the rotation of the biscuit axis in the face plane. On the panel diagram the projection onto the face is athickness × lengthrectangle centered on the biscuit axis.
| Field | Type | Required | Description |
|---|---|---|---|
face | string | when face | "top" | "bottom" |
edge_side | string | when base edge | "xL" | "x0" | "yW" | "y0" |
on_segment | ref | when contour edge | id of an outline/hole segment (§9.2.2) |
x | mm | when face; when edge_side: y0/yW | Biscuit axis — along the length (§9.2.1) |
y | mm | when face; when edge_side: xL/x0 | Biscuit axis — along the width (§9.2.1) |
s | mm | when on_segment | Biscuit axis — along the contour segment (§9.2.2) |
z | mm | no (when edge) | Depth of the axis from the face; default thickness/2 |
angle | degrees | no | Rotation angle of the joint in the surface plane — default 0 |
size_ref | ref | yes | Reference to biscuit_catalog[].id |
10. Path geometry (path)
The path object defines the geometry of a milling operation as a sequence of segments.
| Field | Type | Required | Description |
|---|---|---|---|
start | object | yes | Start point {x, y} — absolute in the panel coordinate system |
closed | bool | yes | true = closed contour, false = open path |
segments | array | yes | Array of segments — min. 1 element |
The start point — x from the bottom edge (along the length), y from the right edge (along the width), in mm.
10.1 Line segment (type: "line")
| Field | Type | Required | Description |
|---|---|---|---|
type | string | yes | "line" |
id | string | no* | Segment identifier — see the note under §10.3 |
end | object | yes | End point {x, y} |
machined | bool | no | (only outline) the segment is a real cut — see §9.3.2 |
10.2 Arc segment (type: "arc")
| Field | Type | Required | Description |
|---|---|---|---|
type | string | yes | "arc" |
id | string | no* | Segment identifier — see the note under §10.3 |
center | object | yes | Arc center {x, y} |
radius | mm | yes | Arc radius |
angle_start | degrees | yes | Start angle (0° = X+ axis) |
angle_end | degrees | yes | End angle |
clockwise | bool | yes | Direction of rotation — maps to G2 (true) / G3 (false) |
machined | bool | no | (only outline) the segment is a real cut — see §9.3.2 |
10.3 Bézier segment (type: "bezier")
| Field | Type | Required | Description |
|---|---|---|---|
type | string | yes | "bezier" |
id | string | no* | Segment identifier — see the note under §10.3 |
cp1 | object | yes | First control point {x, y} |
cp2 | object | yes | Second control point {x, y} |
end | object | yes | End point {x, y} |
machined | bool | no | (only outline) the segment is a real cut — see §9.3.2 |
The machined field is meaningful only for type: outline — it marks a segment that is real machining (a difference of the contour relative to the base rectangle). For the other types it is ignored.
* The id field (string, optional) is required when the segment is the target of on_segment of any edge operation — drilling, biscuit, slot or bevel (§9.2.2). The id MUST be unique within the entire panel (among all path objects of its operations), so that the on_segment reference points to the segment unambiguously without specifying the path.
Each segment starts where the previous one ended. For the first segment, the start point is path.start.
For a closed path (closed: true) the last segment MUST end at the path.start point, or the implementation MUST close the path automatically with a line segment.
11. Catalogs
11.1 Material catalog (materials_catalog)
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique identifier in the catalog |
code | string | no | Manufacturer's catalog code |
name | string | yes | Material name |
manufacturer | string | no | Manufacturer |
category | string | yes | "board" | "veneer" | "laminate" | "paint" | "surface" |
furniture | bool | no | Furniture material — default true (§11.1.1) |
Additional fields depending on category:
board, veneer, laminate:
| Field | Type | Required | Description |
|---|---|---|---|
thickness | mm | yes | Nominal thickness |
grain | string | yes | "along_length" | "along_width" | "none" |
board (only):
| Field | Type | Required | Description |
|---|---|---|---|
sheet | object | yes | Sheet dimensions |
The sheet object:
| Field | Type | Required | Description |
|---|---|---|---|
length | mm | yes | Sheet length (along_length axis) |
width | mm | yes | Sheet width |
trim | mm | yes | Edge trim per edge |
Maximum usable sheet size: sheet.length − 2×trim and sheet.width − 2×trim.
paint:
| Field | Type | Required | Description |
|---|---|---|---|
color_system | string | no | Color system, e.g. "RAL", "NCS" |
color_code | string | no | Color code, e.g. "9016" |
description | string | no | Free-form description, e.g. "biały połysk 90%" |
surface:
| Field | Type | Required | Description |
|---|---|---|---|
color | string | no | Color #RRGGBB, e.g. "#F2F0EB" |
A surface material describes appearance only — plaster, wall paint, steel, glass, plastic — without thickness or sheet. It MUST have furniture: false.
11.1.1 Furniture material (furniture)
The furniture field states whether the material is used in production. A non-furniture material (furniture: false) — wall plaster, hinge steel, a glass pane, a mirror — serves only the appearance or is ordered outside furniture production.
- A production implementation (cutting plan, material requirements, material ordering, machine files) MUST skip panels with a non-furniture material. The panel stays in the file so that the installer can see it in its place.
- An implementation displaying the model SHOULD allow hiding everything that has a non-furniture material with a single command.
- An absent field means
true— files from before version 2.3.0 mean the same as before.
A solid does not go to production regardless of its material (§7.6), and hardware is counted from the hardware catalog (§12), not from the material of its geometry.
11.2 Edge banding catalog (edging_catalog)
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique identifier |
code | string | no | Catalog code |
name | string | yes | Edge banding name |
texture | bool | yes | Whether the edge banding has a structure (texture) |
thickness | mm | yes | Edge band thickness |
height | mm | yes | Band height (before trimming) |
material_ref | ref | yes | Reference to materials_catalog[].id |
11.3 Drilling catalog (drilling_catalog)
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique identifier |
code | string | no | Catalog code |
name | string | yes | Drilling type name |
diameter | mm | yes | Hole diameter |
depth | mm | when through: false | Hole depth |
through | bool | yes | Whether the drilling is a through drilling |
When through: true, the depth field is optional and ignored. The depth of a through drilling is determined by the panel thickness.
11.4 Hardware catalog (hardware_catalog)
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique identifier |
code | string | no | Manufacturer's catalog code |
name | string | yes | Hardware name |
manufacturer | string | no | Manufacturer |
11.5 Geometric profile catalog (profiles)
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique identifier |
code | string | no | Catalog code |
name | string | yes | Profile name |
start | object | no | Start point of the cross-section {x, y} — default {0, 0} |
path | array | yes | Cross-section of the resulting cut geometry — array of segments (line / arc / bezier) |
11.5.1 What a profile describes
A profile describes the cross-section of the resulting cut geometry — the shape created in the material or on the edge. It does not describe the geometry of the cutting tool. Choosing the tool to produce a given profile is CAM knowledge.
11.5.2 Profile coordinate system
A profile describes a cross-section in a local 2D frame. The first point of the cross-section is start (default (0, 0)); the subsequent path segments run from it. The frame depends on the slot placement (§9.3.1):
Slot edge — (0, 0) anchored at the edge corner:
Origin (0, 0) = corner (face ∩ edge_side / on_segment)
X+ = into the material from the edge (perpendicular to the edge, along the face)
Y+ = into the thickness from the face (Y = 0 is the face plane)Slot surface — (0, 0) on the path axis in the face plane:
Origin (0, 0) = path axis on the face plane (face)
X+ = transverse, to the right side of the path relative to its local direction (in the face plane)
Y+ = into the thickness from the face given by the face fieldFor curved segments the local direction (and hence the X axis) follows the tangent to the path at the given point.
Entry surface and depth. The line Y = 0 is the tool entry surface (the face for surface, the edge/corner for edge). The milling depth follows from the reach of the profile into the material — max(Y) over all points of the cross-section. The profile MUST be open and anchored on the entry surface: its extreme ends lie on the line Y = 0, and the removed material is the area enclosed between the profile and this line. A closed profile (a loop) or one detached from Y = 0 describes an infeasible cut (validation, §15.7).
Centering and offset. Because the first point is start, the profile can be positioned freely relative to the trajectory without a separate field — e.g. a slot centered on the path axis is described by a profile starting at start.x = −width/2. In the profiled variant all positioning is baked into the profile (its start and geometry); the slot then has no offset field (§9.3.1).
11.5.3 Examples
R5 roundover on the edge corner:
[{ "type": "arc", "center": { "x": 5, "y": 5 }, "radius": 5,
"angle_start": 270, "angle_end": 180, "clockwise": false }]Interpretation: the new surface runs 5 mm along the face (X=0→5) and 5 mm along the edge (Y=0→5), connecting these points with an R5 arc.
5×3 mm slot, axis 9 mm from the face (slot for an HDF back panel):
[{ "type": "line", "end": { "x": 3, "y": 6.5 } },
{ "type": "line", "end": { "x": 3, "y": 11.5 } },
{ "type": "line", "end": { "x": 0, "y": 11.5 } }]The profile starts at the material boundary (0, 0), plunges 3 mm (X=3), runs between Y=6.5 and Y=11.5 (width 5 mm) and returns to X=0.
12 mm slot with a semicircular R6 bottom, centered on the path axis (slot surface, profiled — uses start):
{
"start": { "x": -6, "y": 0 },
"path": [
{ "type": "line", "end": { "x": -6, "y": 4 } },
{ "type": "arc", "center": { "x": 0, "y": 4 }, "radius": 6,
"angle_start": 180, "angle_end": 0, "clockwise": true },
{ "type": "line", "end": { "x": 6, "y": 0 } }
]
}start = (−6, 0) lies on the entry surface, 6 mm to the side of the path axis (the axis is X = 0); the profile straddles the path by 6 mm on both sides, with the bottom at Y = 10 (milling depth 10 mm) and both ends at Y = 0. Here the frame is that of a surface slot: X transverse to the path, Y into the thickness.
11.6 Biscuit catalog (biscuit_catalog)
The biscuit_catalog field is optional. It is required when operations with type: "biscuit" occur.
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique identifier |
code | string | no | Manufacturer's catalog code |
name | string | yes | Biscuit name |
length | mm | no | Biscuit length |
width | mm | no | Biscuit width (insertion depth into the material) |
thickness | mm | no | Biscuit thickness / recess width measured symmetrically about the axis |
11.7 Mesh catalog (meshes_catalog)
The meshes_catalog field is optional. It is required when any geometry has type: "mesh".
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique identifier |
name | string | yes | Mesh name |
positions | array | yes | Vertex coordinates x, y, z in sequence, in mm, in the solid's coordinate system (§14.5) — length a multiple of 3 |
triangles | array | yes | Vertex indices, three per triangle, counted from 0 — length a multiple of 3 |
The vertices of a triangle are given counterclockwise when looking from outside the solid — the normal points outward (right-handed system). A mesh MAY be open (a surface instead of a solid).
A .meb file is self-contained: a mesh is always embedded in the file itself. The standard does not provide for references to external files or catalogs.
12. Hardware (type: "hardware")
A hardware item is a tree node (§7.2) — a leaf that stands in any group or in the root:
| Field | Type | Required | Description |
|---|---|---|---|
type | string | yes | "hardware" |
id | id | yes | Node identifier, unique in the file — machining operations point to it (§12.1) |
name | string | yes | Free-form label |
hardware_ref | ref | yes | Reference to hardware_catalog[].id |
quantity | number | yes | Number of pieces — integer > 0 |
position | object | no | Position {x, y, z} relative to the parent, mm |
rotation | object | when position | XYZ Euler rotation {x, y, z}, degrees |
material_ref | ref | when position | Reference to materials_catalog[].id — appearance of the hardware item |
geometry | object | when position | Simplified geometry of the hardware item — like a solid (§7.6.1) |
A hardware item without a position is a list item with a quantity (screws, dowels in a bag) in its group — it has no position or rotation.
A hardware item with a position (position) is a single piece in its place: a hinge, a runner, a handle, a fastener. It MUST have rotation, material_ref and geometry, and quantity: 1. The geometry is appearance only: the hardware item is counted and ordered via hardware_ref, not via the material of its geometry.
12.1 Hardware machining
Drillings and milling operations that result from a hardware item point to it with the hardware_instance_ref field. The relation runs from the machining operation to the hardware item, because one hardware item has machining operations on several panels — a cam lock, a runner, a hinge with a mounting plate on the side panel. A machining operation MAY point to a hardware item from another group, including from another cabinet (a connector screwing two cabinets together).
- A machining operation MUST point to a hardware item with a position.
- An implementation that deletes a hardware item MUST delete all machining operations that point to it.
- An implementation that moves a hardware item MUST move all machining operations that point to it together with it.
A fastener (confirmat screw, cam lock, dowel) is described the same way: a hardware item with a position whose drillings on both panels point to the same piece.
13. Grain continuity groups (grain_groups)
A grain continuity group is a block of panels cut from one piece of board so that the grain runs from panel to panel. A block consists of rows laid out one after another along the grain, and a row — of panels laid side by side across the grain; each row has its own alignment (§13.2). A strip of panels cut one after another (the meaning of a group up to version 2.4.0) is a block in which each row has one panel.
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique group identifier |
name | string | yes | Group name |
material_ref | ref | yes | Reference to materials_catalog[].id |
orientation | string | no | Grain relative to the furniture front: "vertical" (default) | "horizontal" — see §13.1 |
kerf | mm | yes | Width of the saw kerf between panels — between rows and between panels in a row |
members | array | yes | Panels in the group — min. 2 elements |
rows | array | no | Row alignment — see §13.2; a row without an entry is aligned to the start edge |
The member object:
| Field | Type | Required | Description |
|---|---|---|---|
panel_ref | ref | yes | Reference to the id of a panel node anywhere in the tree |
row | integer | no | Row number along the grain — integer, sequence 1…n in the group |
order | integer | yes | Position in the row counted from the start edge — integer, sequence 1…m in the row |
The rows[] object (2.6.0):
| Field | Type | Required | Description |
|---|---|---|---|
row | integer | yes | Number of the group row the entry applies to |
align | string | yes | Row alignment: "start" | "center" | "end" — see §13.2 |
13.1 Rows and positions
A block is described in the view onto the face of the panels. The face (top, §14) of a group panel is the side visible from outside the furniture — it is the side you look at when assessing grain continuity, and the rows and positions of the block lie in it. Machining done from the inside of the furniture (e.g. door hinge cup bores) then lies on the back of the panel (bottom). The source program MUST describe every panel of the group with its face outward — a panel described with its face inward would be a mirror image of itself in the block and would get its machining on the wrong side of the grain.
The orientation field states how the grain runs in the block, and determines the rows and the start edge from which the position in a row is counted:
orientation | Grain in the front | Row | Row 1 | Start edge |
|---|---|---|---|---|
"vertical" (default) | vertical | horizontal strip across the entire width of the block | at the top | left |
"horizontal" | horizontal | vertical strip across the entire height of the block (column) | on the left | bottom |
- Rows lie one after another along the grain: the grain runs from row
nto rown + 1. - The panels of a row lie side by side across the grain; position
order: 1is closest to the start edge, and each subsequent one lies further from it — regardless of the row alignment. - All panels of a row have the same dimension along the grain (§15.4).
- A row narrower than the widest one is aligned to the edge indicated by its alignment (§13.2), and the rest of its width lies on the other side.
A member without the row field is a separate row: row number = its order, position in the row = 1. A group without row therefore means exactly the same as in version 2.4.0 and earlier — a strip of panels, each in a separate row. An implementation reading version 2.5.0 and later MUST accept members without row in this meaning.
Example — vertical grain, a row of three fronts 500 mm wide (height 300 mm) above a row of two fronts 750 mm wide (height 1000 mm). The grain runs from three panels into two, and the joints fall in different places:
grain ↓
row 1 │ 1: 500 │ 2: 500 │ 3: 500 │ height 300
row 2 │ 1: 750 │ 2: 750 │ height 1000{
"id": "gg_fronty",
"name": "Fronty zabudowy",
"material_ref": "mat_dab",
"orientation": "vertical",
"kerf": 4.4,
"members": [
{ "panel_ref": "p_szuflada_1", "row": 1, "order": 1 },
{ "panel_ref": "p_szuflada_2", "row": 1, "order": 2 },
{ "panel_ref": "p_szuflada_3", "row": 1, "order": 3 },
{ "panel_ref": "p_drzwi_lewe", "row": 2, "order": 1 },
{ "panel_ref": "p_drzwi_prawe", "row": 2, "order": 2 }
]
}13.2 Row alignment (2.6.0)
Each row has its own alignment — it states to which edge of the block the row is aligned, and therefore on which side the rest of the width of a row narrower than the widest one lies. The alignment is given by an entry in rows[]; a row without an entry has "start", i.e. the meaning from version 2.5.0.
align | Letter (§13.3) | Vertical grain | Horizontal grain | Rest of the row width |
|---|---|---|---|---|
"start" (default) | P — start | to the left | to the bottom | on the end side |
"center" | S — center | in the center | in the center | half on each side |
"end" | K — end | to the right | to the top | on the start side |
Alignment does not change the numbering: positions (order) are always counted from the start edge. A row as wide as the block does not need alignment — the entry changes nothing in it. How the rest of the width is cut (one piece or two, their size after the kerfs) is decided by the cutting plan program.
Example — vertical grain, a row of two drawer fronts 600 mm wide (height 200 mm) above a door 900 mm wide (height 1000 mm) in the center:
grain ↓
row 1 P │ 1: 600 │ 2: 600 │ height 200
row 2 S │ … │ 1: 900 │ … │ height 1000{
"id": "gg_witryna",
"name": "Witryna",
"material_ref": "mat_dab",
"orientation": "vertical",
"kerf": 4.4,
"members": [
{ "panel_ref": "p_witryna_szuflada_1", "row": 1, "order": 1 },
{ "panel_ref": "p_witryna_szuflada_2", "row": 1, "order": 2 },
{ "panel_ref": "p_witryna_drzwi", "row": 2, "order": 1 }
],
"rows": [
{ "row": 2, "align": "center" }
]
}13.3 Position-in-block notation (2.6.0)
The position of a panel in a block is written as a single text #B.RA.P:
| Part | Meaning | Field |
|---|---|---|
B | block number — integer ≥ 1, one per group in the project | group (grain_groups[]) |
R | row number | members[].row |
A | row alignment letter: P — start, S — center, K — end (the same for both grain directions) | rows[].align |
P | position in the row from the start edge | members[].order |
Example: #1.2S.1 — block 1, row 2 aligned to the center, panel 1 in the row; #2.2P.2 — block 2, row 2 aligned to the start, panel 2. Regular expression of the notation: #(\d+)\.(\d+)([PSK])\.(\d+).
The notation serves two purposes:
- a program without grain continuity (e.g. a design program without grain groups) carries the block in the panel names — the designer types the notation into the name while looking at the furniture from outside (§13.1), and the converter to .meb creates groups from it: one group per block number,
rowandorderfrom the notation, arows[]entry from the row letter. All panels of one row MUST have the same letter. The notation does not carry the grain of the block (orientation) — the converter takes it from the grain direction of the panels in the furniture. The converter MAY remove the notation from the panel name, because its content is carried by the group fields, - a program displaying the block (panel list, label, cutting plan) SHOULD write the position of the panel with this notation — it then assigns the block number within its own scope (e.g. within an order).
Group validation rules — see §15.4.
14. Coordinate system
14.1 Canonical panel orientation
All machining operations (face, edge_side, x, y of drillings and milling operations) refer to the canonical base position of the panel, regardless of its rotation in the tree. Convention: face up, length vertical, width horizontal, a right-handed system (consistent with the 3D scene, without mirroring). The x coordinate runs along the length (0..length), y along the width (0..width, increases to the left); origin = the bottom-right corner of the face.
x = length (L) ▲ (vertical; grain “along_length”)
│
┌────────────── xL ─────────────┐ ── x = L (top)
│ │
yW │ FACE │ y0
│ face: top (Z+) │
│ │
└────────────── x0 ─────────────┘ ── x = 0 (origin, bottom-right)
y = W ◄─────────────────────────────── y = 0
(horizontal; width increases to the left)length(L) — length, vertical; coordinatex ∈ [0, L].width(W) — width, horizontal (increases to the left); coordinatey ∈ [0, W].thickness(T) — thickness, Z axis (Z+= face /face: top,Z−= back /face: bottom).edge_sideedges:y0/yW= length edges;xL/x0= width edges.
A milling operation described as face: top always applies to the face of the panel, even when the panel stands vertically in an assembled cabinet. The panel's rotation field is used only for 3D rendering and for generating assembly diagrams (local 3D frame: length → X, width → Y, thickness → Z).
14.2 Group coordinate system and front
The local coordinate system of every group — a cabinet, a drawer, a set:
Z+ (up)
│
│ Y+ (back)
│ /
│ /
│ /
└────── X+ (right)
front = side Y- (doors / drawer fronts) — default
cabinet origin = left-bottom-front corner of the outline (outer)Child positions are given in the group's coordinate system — the left side panel of a cabinet starts at x = 0.
The front of a group is the side indicated by the front field, default -Y; the top is +Z. The orientation of the group in the scene is carried by its rotation (rotation) — a cabinet moved to another wall faces the new direction together with its rotation. The front field is editable: a program whose group coordinate system has its front on another side states that side in the field. An implementation MAY rewrite the group's coordinate system so that the front is -Y (rotating the coordinate system about Z and recomputing the child positions) — the group does not move in the scene when this is done.
The production drawing of a cabinet (a group with the role "cabinet") is always generated from its coordinate system, looking at the front. The cabinet's rotation field in the tree is ignored by production software when generating drawings.
14.3 Cascading transformation principle
Each node defines position and rotation relative to its parent. The global position of an object is determined by composing the transformations of all its ancestors:
global_position = T(group_1) × T(group_2) × ... × T(group_n) × T(node)This model is directly compatible with Object3D in Three.js and Babylon.js.
14.4 Panel size and edge banding
The dimensions in the dimensions field are always the finished size after edge banding — they already include the edge banding.
The .meb standard does not describe the raw size (before edge banding). Any reduction of the size by the edge band thickness is a task of the edge banding technology carried out on the machine itself and depends on its parameters. Cutting plan and preview implementations operate solely on the finished size from the dimensions field.
14.5 Solid and hardware coordinate system
A solid and a hardware item with a position have their own local right-handed coordinate system, placed by position and rotation relative to the parent (§14.3) — a group or the root.
extrusion— the outline lies in theXYplane of the solid's coordinate system, the extrusion runs fromZ = 0toZ = thickness,mesh— thepositionscoordinates are given in the solid's coordinate system, in mm,polyhedron— the vertex coordinates are given in the solid's coordinate system, in mm.
15. Validation rules
15.1 Uniqueness of identifiers
An implementation MUST report a validation error when:
- two tree nodes (group, panel, hardware item, solid) have an identical
id - two entries in the same catalog have an identical
id - two vertices, two edges or two faces of one polyhedron have an identical
id
Identifiers ARE global within their collection. A node id is global across the whole tree, regardless of the node type and the group in which it stands. The identifiers of polyhedron elements are local: unique within their list in one polyhedron.
15.2 Reference integrity
Every *_ref reference MUST point to an existing id in the target collection:
| Reference | Target |
|---|---|
panel.material_ref | materials_catalog[].id |
panel.composite.layers[].material_ref | materials_catalog[].id (category board) |
panel.grain_group_ref | grain_groups[].id |
panel.edging.{side}.ref | edging_catalog[].id |
edging_catalog[].material_ref | materials_catalog[].id |
drilling.drilling_ref | drilling_catalog[].id |
routing.profile_ref (type: slot, section: profiled) | profiles[].id |
routing.size_ref (type: biscuit) | biscuit_catalog[].id |
routing.edging.ref | edging_catalog[].id |
hardware.hardware_ref (hardware node) | hardware_catalog[].id |
hardware.material_ref | materials_catalog[].id |
solid.material_ref (solid node) | materials_catalog[].id |
geometry.mesh_ref | meshes_catalog[].id |
geometry.edges[].start, geometry.edges[].end, geometry.faces[].loops[][] | vertices[].id of the same polyhedron |
drilling.hardware_instance_ref, routing.hardware_instance_ref | id of a hardware node with a position |
grain_group.material_ref | materials_catalog[].id |
grain_group.members[].panel_ref | id of a panel node in the tree |
comment_refs[] | comments[].id |
15.3 Value ranges
| Field | Condition |
|---|---|
dimensions.length, width, thickness | > 0 |
drilling.x, y | ≥ 0 |
bevel.angle | 0 < angle < 90 |
bevel.leave | ≥ 0 |
bend.radius | > 0 |
bend.angle | 0 < angle ≤ 360 |
hardware.quantity (hardware node) | integer > 0; = 1 when the hardware item has position |
geometry.thickness (extrusion) | > 0 |
grain_group.kerf | > 0 |
finish.order | integer > 0 |
edge_finish.chamfer (panel and routing) | ≥ 0 and 2 × chamfer < dimensions.thickness |
15.4 Validation of grain continuity groups
In these rules a member without row is a row whose number equals its order, with position 1 (§13.1).
An implementation MUST report an error when:
- The same panel belongs to more than one grain group.
- A panel in the group uses a material other than
grain_group.material_ref. - The row numbers in the group do not form a continuous sequence (1, 2, …, n), or the positions in some row do not form a continuous sequence without repetitions (1, 2, …, m). In a group without
rowthis is the previous rule: theordervalues form a continuous sequence without repetitions (1, 2, …, n). - The panels of one row have different dimensions along the grain
D(panel). - The block does not fit in the usable sheet along or across the grain:
D(panel) = dimensions.length when panel.grain = "along_length" ← dimension along the grain
D(panel) = dimensions.width when panel.grain = "along_width"
C(panel) = dimensions.width when panel.grain = "along_length" ← dimension across the grain
C(panel) = dimensions.length when panel.grain = "along_width"
D(row) = D(panel) of the row's panels (common — item 4)
C(row) = Σ C(i) + (m − 1) × kerf m — number of panels in the row
Σ D(row) + (n − 1) × kerf ≤ max_along_grain n — number of rows
max C(row) ≤ max_across_grainwhere max_along_grain = sheet.length − 2×trim and max_across_grain = sheet.width − 2×trim when the material grain runs along the sheet length (material.grain = "along_length"); with material.grain = "along_width" — the other way round.
In a group without row each row has one panel: item 5 along the grain is the previous rule Σ D(i) + (n − 1) × kerf ≤ max_along_grain, and across the grain it coincides with §15.5.
- A
rows[]entry points to a row that does not exist in the group, or two entries point to the same row (2.6.0).
File validation cannot check that the panel face is outward (§13.1) — this lies in the scene and in the designer's intent; the source program is responsible for it.
15.5 Panel size validation
A panel MUST fit in the material sheet:
panel.dimensions.length ≤ sheet.length − 2×trim
panel.dimensions.width ≤ sheet.width − 2×trimor after rotation by 90° — only when material.grain = "none" or panel.grain = "none":
panel.dimensions.width ≤ sheet.length − 2×trim
panel.dimensions.length ≤ sheet.width − 2×trimIf both — the material and the panel — have a defined grain (grain ≠ "none"), rotation is not allowed.
The rule is consistent with the grain hierarchy (§8.3): rotation is blocked only in the situation where the material has a grain and the panel respects it (panel.grain ≠ "none"). When the material has no grain, panel.grain has no significance.
15.6 Composition validation (composite)
An implementation MUST report an error when:
- The sum of the layer thicknesses is not equal to
panel.dimensions.thickness:Σ layers[].thickness ≠ dimensions.thickness. - The
ordervalues do not form a continuous sequence 1…n (repetitions or gaps). - A layer's
material_refpoints to a material other thanboard.
15.7 Operation validation
| Condition | Error |
|---|---|
Bevel leave + depth > dimensions.thickness | error |
Bevel with multiple entries on the same edge from the same side without the depth field | error |
Bevel without exactly one of edge_side / on_segment | error |
Bevel on_segment targeting a segment other than line | error |
Slot without exactly one placement (path or edge_side/on_segment) | error |
Slot section: simple without width+depth; section: profiled without profile_ref | error |
Slot profiled: profile closed or not anchored on Y=0 (infeasible cut) | warning |
on_segment targeting a segment without an id, a non-existent segment or one whose id is ambiguous within the panel | error |
on_segment outside a through segment (outline machined / hole) | error |
| Milling path outside the panel outline | warning |
edging.sequence outside the enum (width_first | length_first) | error |
routing.edging.pre_trim: true outside type: outline with a single straight machined segment | error |
machined on a segment of an operation other than outline | warning |
15.8 Edge finish validation (edge_finish)
An implementation MUST report an error when:
- The same panel edge has both edge banding and a finish —
edging.{side}andedge_finish.{side}are both non-null. - The same wall of an
outline/holecontour is indicated both inedging.walls(in any entry) and inedge_finish.wallsof the same operation."all"indicates all real cut walls. - The chamfer does not fit within the panel thickness:
2 × chamfer ≥ dimensions.thickness— forpanel.edge_finishandrouting.edge_finish.
15.9 Validation of solids and hardware
An implementation MUST report an error when:
- The outline or a hole of an
extrusiongeometry is not closed (closed: false). - A hole of an
extrusiongeometry extends beyond the outline or intersects another hole. - The length of the mesh's
positionsortrianglesis not a multiple of 3, the mesh has fewer than 3 vertices, or an index intrianglespoints to a non-existent vertex. - A hardware item with
positionhas noid,rotation,material_reforgeometry, or has aquantityother than 1. hardware_instance_refpoints to a hardware item without a position.- A material with
category: surfacedoes not havefurniture: false. - A node other than a group contains
children. - A polyhedron edge has
startequal toend. - A polyhedron face loop has fewer than 3 vertices, repeats a vertex, or two of its consecutive vertices are not the ends of any edge from
edges. - A polyhedron face vertex lies further than 0.01 mm from the face plane, or a face hole extends beyond the outline or intersects the outline or another hole.
15.10 Tree validation (3.0.0)
An implementation MUST report an error when:
- A node other than a group contains
children. - A group with the role
"cabinet"has among its descendants — at any depth — a group with the role"cabinet". - In a file with 3D data (
project.has_3dother thanfalse) a node that is not a hardware item without a position has nopositionorrotation.
A role that the implementation does not know is not an error — the group then counts as a group without a role (§7.4).
16. Comments (comments)
| Field | Type | Required | Description |
|---|---|---|---|
id | id | yes | Unique comment identifier |
author | string | no | Comment author |
date | datetime | no | Date added |
text | string | yes | Comment text |
Comments are stored in the global comments[] list. Objects refer to them via the comment_refs[] array. The same comment MAY be assigned to multiple objects.
Objects supporting comment_refs[]: tree nodes (group, panel, hardware, solid), bevel, drilling, routing, finish.
Appendix A — Table of required fields by object
| Object | Required fields |
|---|---|
MebFile | meta, project, scene, materials_catalog, edging_catalog, drilling_catalog, hardware_catalog, profiles |
meta | version, created_at |
project | id, name |
node | id, name, type + position, rotation (except for a hardware item without a position and a file without 3D data) |
group | + children |
solid (node) | + material_ref, geometry |
geometry (extrusion) | type, outline, thickness |
geometry (mesh) | type, mesh_ref |
geometry (polyhedron) | type, vertices, edges, faces |
geometry.vertices[] | id, x, y, z |
geometry.edges[] | id, start, end |
geometry.faces[] | id, loops |
panel (node) | type, id, name, dimensions, material_ref, grain + position, rotation in a file with 3D data |
panel.edge_finish.{side} | sanded, chamfer |
composite | layers (min. 2 elements) |
composite_layer | order, material_ref, thickness |
bevel | from_face, angle, leave + (edge_side or on_segment) |
drilling (face) | drilling_ref, type: face, face, x, y |
drilling (edge/side) | drilling_ref, type: edge, edge_side + x (L/R) or y (T/B); z optional |
drilling (edge/contour) | drilling_ref, type: edge, on_segment, s; z optional |
routing (slot/surface/simple) | type, section: simple, face, path, width, depth |
routing (slot/surface/profiled) | type, section: profiled, face, path, profile_ref |
routing (slot/edge/simple) | type, section: simple, face, (edge_side or on_segment), width, depth |
routing (slot/edge/profiled) | type, section: profiled, face, (edge_side or on_segment), profile_ref |
routing (outline) | type, path |
routing (hole) | type, path |
routing.edge_finish (outline / hole) | walls, sanded, chamfer |
routing (pocket) | type, face, path, depth |
routing (biscuit/edge-side) | type, edge_side, size_ref + x (L/R) or y (T/B); z optional |
routing (biscuit/edge-contour) | type, on_segment, s, size_ref; z optional |
routing (biscuit/face) | type, face, size_ref, x, y |
material (board) | id, name, category, thickness, grain, sheet |
material (veneer/laminate) | id, name, category, thickness, grain |
material (paint) | id, name, category |
material (surface) | id, name, category, furniture: false |
meshes_catalog | id, name, positions, triangles |
edging_catalog | id, name, texture, thickness, height, material_ref |
drilling_catalog | id, name, diameter, through + depth when through: false |
hardware_catalog | id, name |
profiles | id, name, path |
hardware (node) | type, id, name, hardware_ref, quantity |
hardware (with position) | + position, rotation, material_ref, geometry; quantity: 1 |
grain_group | id, name, material_ref, kerf, members |
grain_group.member | panel_ref, order |
comment | id, text |
Appendix B — Reading 2.x files
An implementation reading version 3.0 MAY read 2.x files. When it reads them, it SHOULD convert them on reading to the 3.0 tree and continue working along a single path:
| 2.x | 3.0 |
|---|---|
node type: "cabinet" | group type: "group", role: "cabinet", with the same id, name, position, rotation, production_id, comment_refs and front |
cabinet.panels[] | children of the cabinet with type: "panel" |
cabinet.hardware[] | children of the cabinet with type: "hardware"; a hardware item without an id gets an identifier unique in the file, and one without a name gets the name from hardware_catalog |
cabinet.solids[] | children of the cabinet with type: "solid" |
group and solid nodes | unchanged |
grain_groups, catalogs, comments | unchanged — panel identifiers do not change |
Version 2.6.0 is the last 2.x version.