Glossary of the .meb standard
Status:
[x]ready — version 3.0.0
Every term has one unambiguous definition that applies throughout the documentation and in the structure of the JSON file.
Project structure
Project
JSON equivalent: project
Definition: The main object describing a design job. It contains identification data (name, description), designer data and the complete spatial model of the fitted furniture.
Used in JSON fields: project
Designer
JSON equivalent: designer
Definition: The person or company responsible for the design. Contact details: first name, last name, e-mail, phone, company name.
Used in JSON fields: project.designer
Scene
JSON equivalent: scene
Definition: A list of root nodes that build the three-dimensional model of the project. The scene is the root of the scene graph and can contain any number of groups, cabinets and solids.
Used in JSON fields: scene
Node
JSON equivalent: node
Definition: The basic element of the scene graph. Every node has a type (group, panel, hardware or solid), an identifier unique within the file, and a position and rotation relative to its parent; only a group has children. Nodes form a tree in which every object inherits the transformations of its ancestors — like the document tree of a design program (3.0.0).
Used in JSON fields: nodes in scene[] and children[]
Group
JSON equivalent: group
Definition: A node that aggregates other nodes — groups, panels, hardware and solids. It represents a room, a set of cabinets, a cabinet, a drawer, a subassembly or any other collection; what it is for production and rules is stated by its role. The group name is a free-form label.
Used in JSON fields: nodes with type: "group" and children[]
Group role
JSON equivalent: group.role
Definition: A field stating what a group is for production and rules. It is assigned to an existing group — three drawers grouped into a group with the cabinet role — and the group remains the same group with the same children. No role means an ordinary group: a drawer, a subassembly, a set, a room. An implementation treats an unknown role as no role.
Used in JSON fields: group.role
Values: "cabinet"
Version: 3.0.0
Cabinet
JSON equivalent: group with role: "cabinet"
Definition: A group representing a single furniture carcass — the unit of production and of the production number. Its children are panels, hardware, built-in solids and groups without a role (drawers, subassemblies). There is no cabinet inside a cabinet at any depth. Up to version 2.x a cabinet was a separate node type (type: "cabinet") with the lists panels[], hardware[] and solids[].
Used in JSON fields: nodes with type: "group" and role: "cabinet"
Group front
JSON equivalent: group.front
Definition: A field specifying which side of the group's coordinate system is its front (the side of the doors and drawer fronts). Every group has it, not only a cabinet; the value is stored as a direction in the group's local coordinate system. Default "-Y" — like the front of a block in a design program; editable for programs whose coordinate system has the front on a different side. Drawings show the group from the front, regardless of its rotation in the tree. Up to version 2.x — cabinet.front.
Used in JSON fields: group.front
Values: "-Y" | "+Y" | "-X" | "+X"
Default: "-Y"
Solid
JSON equivalent: solid
Definition: Any geometry with a material: a wall, a floor, a ceiling, a column, a fitted-furniture massing block, a household appliance, a decoration. The standard does not distinguish kinds of solids — the name is a free-form label, and whether an object concerns production is stated by its material (furniture material). A solid does not go to production. It is a tree node (type: "solid") at the root or in any group — a built-in appliance is a child of the cabinet and travels together with it.
Used in JSON fields: nodes with type: "solid"
Solid geometry
JSON equivalent: geometry
Definition: The shape of a solid or of a hardware item with a position. It has three forms: an outline with thickness (extrusion) — an outline in a plane with holes, extruded to a thickness, exactly like a panel (a wall with a window, a floor, a ceiling); a triangle mesh (mesh) for everything an outline cannot describe; and a polyhedron (polyhedron) — a solid made of flat polygonal faces, just as the program draws it.
Used in JSON fields: solid.geometry, hardware.geometrytype values: extrusion | mesh | polyhedron
Polyhedron
JSON equivalent: polyhedron
Definition: Solid geometry made of vertices, edges and flat polygonal faces with holes — a wall with a window cut right through, a sloped ceiling, a room with a floor and walls in one solid. Every element has an id that the program preserves between edits, so the solid comes back from the file without loss. It can be open (a face without thickness, an edge without a face) and consist of several pieces. A fold edge (fold) arises when a face has stopped being flat and has folded into triangles.
Used in JSON fields: geometry.vertices[], geometry.edges[], geometry.faces[]
Mesh catalog
JSON equivalent: meshes_catalog
Definition: A library of triangle meshes embedded in the file. One mesh can serve many solids and hardware items (ten hinges — one mesh). A .meb file is complete: it has no references to external files or catalogs.
Used in JSON fields: meshes_catalog[], geometry.mesh_ref
Panels
Panel
JSON equivalent: panel
Definition: A single board element — a tree node that stands in a cabinet, in a drawer, in any other group or at the root (a worktop above a set). Described by its dimensions, material, grain direction, edge banding and machining operations. It has its own position and rotation relative to its parent.
Used in JSON fields: nodes with type: "panel"
Dimensions
JSON equivalent: dimensions
Definition: The three dimensions of a panel: length (length), width (width), thickness (thickness) — all in millimeters. In the canonical view the length is vertical and the width horizontal. The dimensions are always the final dimensions after edge banding — they already include the edge banding; the reduction by its thickness is done by the edge bander.
Used in JSON fields: panel.dimensions
Unit: mm
Canonical panel orientation
JSON equivalent: canonical panel orientation
Definition: The agreed base position of a panel in which all machining operations are described: the panel lies face up (Z+), length (length) vertical, width (width) horizontal. The operation coordinate x runs along the length, y along the width (increasing to the left); origin = bottom-right corner (right-handed system, consistent with the 3D scene). Edges: y0/yW = length edges (y0 = y=0 on the right, yW = y=W on the left), xL/x0 = width edges (xL = x=L at the top, x0 = x=0 at the bottom). The rotation field rotates the panel to its assembly position in the cabinet (local 3D frame: length → X, width → Y, thickness → Z), but does not change the interpretation of the face and edge_side fields or of the operation coordinates x, y — these always refer to the canonical system. Likewise, a cabinet's rotation in the scene graph is ignored by production software when generating drawings.
Used in JSON fields: the rule applies to panel.face, panel.edge_side, drilling.x/y, routing.path
Grain direction
JSON equivalent: grain
Definition: The orientation of the grain/texture of the board. Grain is a property of the material only: material.grain describes whether the material has grain and its base direction. panel.grain is subordinate — it determines whether the given panel respects the grain and in which direction (none = does not respect it). When the material has no grain (material.grain = "none"), panel.grain is ignored. The value along_length means grain along the length (x axis, vertical), along_width — along the width (y axis, horizontal). It matters for the cutting plan and for aesthetics (see specification §8.3, §15.5).
Used in JSON fields: material.grain, panel.grain
Values: along_length | along_width | none
Grain continuity
Grain group
JSON equivalent: grain_group
Definition: A block of panels cut from one piece of board so that the grain is continuous between them. A block consists of rows laid one after another along the grain, and a row — of panels laid side by side across the grain; all panels of a row have the same dimension along the grain, and each row has its own alignment. A strip of panels cut one after another is a block in which each row has one panel. The block is described in the view of the panels' faces, and the face of a group's panel is the side visible from outside the furniture (see Face of a grain group panel). A group has a unique identifier, a name, a material reference, grain relative to the front, a list of members (members[]) with the row and the position in the row, and row alignment (rows[]). A single panel can belong to at most one grain group (see specification §13, §15.4).
Used in JSON fields: grain_groups[]
Grain relative to the front
JSON equivalent: grain_group.orientation
Definition: The grain direction of the block in the view of the panels' faces (the side visible from outside the furniture). It determines the rows and the starting edge: with vertical grain (vertical, default) the rows are horizontal strips, row 1 is at the top, and positions in a row are counted from the left edge; with horizontal grain (horizontal) the rows are columns, row 1 is on the left, and positions are counted from the bottom edge. Which edge a row is pushed against is stated by the row alignment. It does not replace the panel grain direction (panel.grain), which describes the grain in the canonical panel orientation.
Used in JSON fields: grain_group.orientation
Values: vertical | horizontal
Face of a grain group panel
JSON equivalent: face: top of a panel in grain_groups[]
Definition: The top face (top) of a panel belonging to a grain group is its side visible from outside the furniture — it is what one looks at when assessing grain continuity, and the rows and positions of the block lie in it. Machining operations performed from the inside of the furniture (e.g. door hinge cup holes) then lie on the bottom face (bottom). The source program describes a group's panel with its face outward — a panel described with its face inward would be a mirror image of itself in the block (see specification §13.1).
Version: 2.6.0 (clarification)
Row alignment
JSON equivalent: grain_group.rows[].align
Definition: The edge of the block against which a row narrower than the widest one is pushed: start (start, default — left with vertical grain, bottom with horizontal grain), center (center) or end (end — right with vertical grain, top with horizontal grain). The rest of the row's width lies on the other side; with center — half on each side. Each row has its own alignment; a row without an entry in rows[] is aligned to the start. Alignment does not change the position numbering (see specification §13.2).
Used in JSON fields: grain_group.rows[].align
Values: start | center | end
Version: 2.6.0
Position-in-block notation
JSON equivalent: notation #B.RA.P
Definition: Text describing a panel's position in a grain continuity block: the block number, the row number with the alignment letter (P — start, S — center, K — end) and the position in the row. A program without grain groups uses it to carry the block in panel names, and a converter creates groups from it; a program that shows the block uses it to write the panel's position (see specification §13.3).
Example: #1.2S.1 — block 1, row 2 aligned to the center, panel 1 in the row
Version: 2.6.0
Grain group reference
JSON equivalent: grain_group_ref
Definition: A field on a panel indicating which grain continuity group the element belongs to. Optional — absence of the field means no grain continuity requirement for this panel.
Used in JSON fields: panel.grain_group_ref
Row in a grain group
JSON equivalent: grain_group.members[].row
Definition: An integer specifying the panel's row number in the block, counted along the grain from row 1 (at the top with vertical grain, on the left with horizontal grain). The row numbers in a group form a continuous sequence: 1, 2, …, n; the grain passes from row n to row n + 1. Panels of one row have the same dimension along the grain. Optional field — a member without row is a separate row with a number equal to its order, so groups from files 2.4.0 and older keep the meaning of a strip of panels.
Used in JSON fields: grain_group.members[].row
Order in a grain group
JSON equivalent: grain_group.members[].order
Definition: An integer specifying the panel's position in its row, counted across the grain from the starting edge (left with vertical grain, bottom with horizontal grain) in the face view, regardless of the row alignment. In each row the values form a strict sequence without repetitions: 1, 2, …, m; the panel with order: 1 is closest to the starting edge. A member without row is a separate row with a number equal to order and position 1 — so in a group without row, order is the order of the panels in the strip along the grain, as in version 2.4.0 and older.
Used in JSON fields: grain_group.members[].order
Kerf
JSON equivalent: kerf
Definition: The width of material lost in each saw cut between adjacent panels in a grain group — between rows and between panels in a row — in millimeters. Typical value: 4.4 mm. Used to validate whether the block fits in one sheet: along the grain Σ row dimensions + (n−1) × kerf (n — number of rows), across the grain the widest row Σ panel dimensions + (m−1) × kerf (m — number of panels in the row).
Used in JSON fields: grain_group.kerf
Unit: mm
Example: a row of 3 panels 500 mm wide and 300 mm high above a row of 2 panels 750 mm wide and 1000 mm high, kerf 4.4 mm → a block of 1304.4 mm along the grain (300 + 1000 + 4.4) and 1508.8 mm across it (3 × 500 + 2 × 4.4)
Coordinate system and positioning
Position
JSON equivalent: position
Definition: A point in 3D space expressed as {x, y, z} in millimeters. Every node and every panel has a position relative to its parent. The global position of an object is the sum of the positions of all its ancestors in the tree.
Used in JSON fields: node.position, panel.position
Unit: mm
Rotation
JSON equivalent: rotation
Definition: The rotation of an object in 3D space expressed as XYZ Euler angles in degrees {x, y, z}. Rotation is always relative to the parent. For furniture elements the typical values are multiples of 90°.
Used in JSON fields: node.rotation, panel.rotation
Unit: degrees (°)
Plane
JSON equivalent: face
Definition: One of the two main planes of a panel: top (top face) or bottom (bottom face). It specifies from which side a drilling or milling operation is performed.
Used in JSON fields: drilling.face, routing.face
Values: top | bottom
Edge
JSON equivalent: edge_side
Definition: One of the four side edges of a panel: y0/yW are the length edges (vertical sides), xL/x0 are the width edges (horizontal sides). The names are anchored in the coordinate: y0 = y=0, yW = y=W, xL = x=L, x0 = x=0. Used to describe edge banding and operations on edges.
Values: xL | x0 | yW | y0
Panel composition
Composite panel
JSON equivalent: composite panel
Definition: A panel whose thickness results from gluing together several thinner layers (boards). Example: a 36 mm panel produced as two 18 mm layers. Marked by the composite field in the .meb format. Absence of this field means a monolith — a panel from a single sheet, which is not to be broken down into components.
Used in JSON fields: panel.composite
Composite layers
JSON equivalent: composite layers
Definition: The list of component boards that make up a composite panel. Each layer has an order (order), a material reference and a thickness. The sum of the layer thicknesses must equal panel.dimensions.thickness. Order: order: 1 = bottom/back layer, order: n = top/front layer — following the gluing order.
Used in JSON fields: panel.composite.layers[]
Panel bending
Bend
JSON equivalent: bend
Definition: An optional object describing the bending of a panel along one axis. A bent panel has the geometry of a cylindrical segment — it is not flat. Operation coordinates (drillings, millings, groovings) are given in the coordinate system of the panel unfolded flat; the 3D viewer maps them onto the curved surface.
Used in JSON fields: panel.bend
Bend axis
JSON equivalent: bend.axis
Definition: Specifies along which dimension the bend arc runs. length — bending along the length (dimensions.length). width — bending along the width (dimensions.width). A panel can be bent along one axis only (cylindrical bending).
Used in JSON fields: panel.bend.axis
Values: width | length
Bend radius
JSON equivalent: bend.radius
Definition: The arc radius in millimeters. The radius type is specified by radius_type. The other radius is calculated from the formula: outer_radius = inner_radius + panel.dimensions.thickness.
Used in JSON fields: panel.bend.radius
Unit: mm
Radius type
JSON equivalent: bend.radius_type
Definition: Specifies whether the given radius is the inner radius (inner — the concave side) or the outer radius (outer — the convex side).
Used in JSON fields: panel.bend.radius_type
Values: inner | outer
Arc angle
JSON equivalent: bend.angle
Definition: The bend angle of the panel in degrees. Technically redundant — it can be calculated from the formula angle = (arc_length / radius) × (180 / π), where arc_length is dimensions.length or dimensions.width depending on the bend axis. Given explicitly for readability and for the convenience of implementers.
Used in JSON fields: panel.bend.angle
Unit: degrees (°)
Edge banding
Edge banding
JSON equivalent: edging
Definition: Edge band tape (ABS, PVC, veneer) glued onto the edge of a panel. Each of the four edges can have different edge banding or none at all.
Used in JSON fields: panel.edging
Edge banding catalog
JSON equivalent: edging_catalog
Definition: A library of the edge banding types used in the project. Each entry contains: code, name, texture flag, thickness, height and a material reference. Panels refer to the catalog via ref.
Used in JSON fields: edging_catalog[]
Edge banding sequence
JSON equivalent: edging.sequence
Definition: Specifies which pair of opposite edges is banded first: "width_first" (the widths xL/x0 first) or "length_first" (the lengths y0/yW first). The pair banded later covers the corners of the earlier pair. The pair model reflects the physical order on the edge bander — an arbitrary order of individual sides is not representable. It affects the edge dimensions and the appearance of the corners in the 3D model. Default "width_first".
Used in JSON fields: panel.edging.sequence
Edge finish
JSON equivalent: edge_finish
Definition: A description of an edge that is not banded but finished on the board itself: sanded (sanded) and/or chamfered (chamfer — the size of a 45° chamfer on both corners of the edge, at the face and at the back; 0 = no chamfer). Typical for HPL compact boards: sanding + a 1×1 mm chamfer. It describes the appearance of the finished edge, not the machine or the process. An edge has either edge banding or a finish. An edge finish is something different from a surface finish (finishes[] — a layer of material applied to a surface: veneer, laminate, lacquer) and something different from a bevel (bevels[] — 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. Absence of the field means that the file says nothing about the edge finish.
Used in JSON fields: panel.edge_finish, routing.edge_finish (outline, hole)
Unit: mm (chamfer)
Materials
Material
JSON equivalent: material
Definition: A description of a material used in the project. The category (category) specifies the type: board (board), veneer (veneer), laminate (laminate), lacquer/paint (paint) or appearance only (surface). Panels, edge banding, surface finishes, solids and hardware items with a position refer to materials via material_ref.
Used in JSON fields: materials_catalog[], panel.material_ref, edging_catalog[].material_ref, finish.material_ref
Material category
JSON equivalent: material.category
Definition: The material type, which determines the available fields and the way of use:
board— sheet board (hassheet,thickness,grain)veneer— veneer (hasthickness,grain)laminate— laminate (hasthickness)paint— lacquer or paint (hascolor_system,color_code,description)surface— appearance only: plaster, steel, glass, plastic (hascolor); always a non-furniture material
Used in JSON fields: material.category
Values: board | veneer | laminate | paint | surface
Furniture material
JSON equivalent: material.furniture
Definition: A property of a material stating whether furniture is produced from it. A production implementation skips panels with a non-furniture material (glass pane, mirror, sheet metal), and an implementation displaying the model allows hiding, with one command, everything that has a non-furniture material (walls, appliances, hardware). Absence of the field means a furniture material.
Used in JSON fields: material.furniture
Default: true
Sheet dimensions
JSON equivalent: sheet
Definition: The physical dimensions of a board sheet: length (length) and width (width) in millimeters. The length runs along the grain of the material (along_length). A required field for every material — used to validate panel sizes.
Used in JSON fields: material.sheet
Unit: mm
Trim
JSON equivalent: trim
Definition: An allowance in millimeters cut off each edge of the sheet before the actual cutting plan, in order to obtain a straight and clean edge. The maximum usable sheet size is: sheet.length - 2×trim and sheet.width - 2×trim. A required field.
Used in JSON fields: material.sheet.trim
Unit: mm
Example: trim: 16 → a 2800×2070 sheet gives a max usable size of 2768×2038 mm
Surface finishes
Surface finish
JSON equivalent: finish
Definition: A layer applied to a plane or an edge of a panel: veneer, laminate, lacquer or paint. Finishes are defined in the order of application (order). They can be combined — e.g. first veneer, then lacquer on the same surface. Finishes with thickness > 0 (veneer, laminate) increase the final thickness of the panel, which is included in dimensions.thickness.
Used in JSON fields: panel.finishes[], routing.finishes[]
Note: In the context of routing operations (routing.finishes[]) the surface field is omitted — the finished surface is implicitly the surface milled by the given operation.
Finish surface
JSON equivalent: finish.surface
Definition: Specifies which surface of the panel the finish covers. Values for planes: face_top (top face), face_bottom (bottom face). Values for edges: edge_xL, edge_x0, edge_y0, edge_yW. The same finish can be applied to one surface only — for several surfaces, separate entries must be added to finishes[].
Used in JSON fields: finish.surface
Values: face_top | face_bottom | edge_xL | edge_x0 | edge_y0 | edge_yW
Finish application order
JSON equivalent: finish.order
Definition: An integer specifying the order in which finishes are applied on the same surface. Lower number = applied earlier. Finishes on different surfaces can have the same numbers — the order applies only to the same surface value.
Used in JSON fields: finish.order
Machining operations
Angled cut (bevel)
JSON equivalent: bevel
Definition: Cutting a panel edge with a saw at an angle. It can be partial — part of the thickness remains straight (leave), the rest is cut at an angle. Several bevels can occur on one edge (e.g. from the top and from the bottom, or two from the top at different angles) — each as a separate entry in bevels[], processed in array order. Addressed by edge_side (base side) or on_segment (a straight line segment of an outline/hole); it always covers the entire edge.
Used in JSON fields: panel.operations.bevels[]
Bevel angle
JSON equivalent: bevel.angle
Definition: The angle of the angled cut in degrees, measured from the perpendicular to the panel plane. 0° = perpendicular cut (straight side), 45° = standard bevel, 90° = cut parallel to the plane (theoretical maximum).
Used in JSON fields: bevel.angle
Unit: degrees (°)
Bevel straight leave
JSON equivalent: bevel.leave
Definition: The thickness of material in mm left straight before the bevel, measured from from_face. The value 0 means cutting from the very edge of the plane. With several bevels from the same side — each subsequent leave is counted from the same plane (from_face).
Used in JSON fields: bevel.leave
Unit: mm
Bevel depth
JSON equivalent: bevel.depth
Definition: The depth of the angled cut in mm, measured perpendicular to the panel plane. Optional — when omitted, the bevel covers all the remaining material: depth = thickness - leave. Required when more than one bevel is defined on the same edge from the same side (from_face).
Used in JSON fields: bevel.depth
Unit: mm
Edge banding on a bevel
JSON equivalent: bevel.edging
Definition: Optional edge banding glued onto the beveled surface after cutting. Required width of the edge band roll: height ≥ depth / sin(angle).
Used in JSON fields: bevel.edging
Drilling catalog
JSON equivalent: drilling_catalog
Definition: A library of the drilling types used in the project. Each entry defines the technical parameters of a hole: diameter, depth and type. Drilling instances on a panel refer to the catalog via drilling_ref.
Used in JSON fields: drilling_catalog[]
Drilling
JSON equivalent: drilling
Definition: An instance of a drilling operation on a panel. It specifies the drilling type (a catalog reference), whether the operation concerns a plane (face) or an edge (edge), and the position of the hole through the x and y coordinates.
Used in JSON fields: panel.operations.drillings[]
Through drilling
JSON equivalent: through drilling
Definition: A hole passing through the entire thickness of the panel. Defined by through: true in the drilling catalog — the depth value is optional and calculated from the panel thickness (material.thickness).
Used in JSON fields: drilling_catalog[].through
Drilling coordinate system
JSON equivalent: drilling coordinates
Definition: The coordinates specify the position of the hole center in the canonical system (§9.2.1): x along the length, y along the width, z across the thickness — depth from the top face (face: top), z ∈ [0, thickness], default thickness/2.
- Plane (
type: face) —xfrom the bottom edge (along the length),yfrom the right edge (along the width);zdoes not apply (depth from the catalog) - Length edge (
edge_side: y0/yW) —xposition along the length;yimplied byedge_side(y0→y=0,yW→y=W); depth within the thickness inz - Width edge (
edge_side: xL/x0) —yposition along the width;ximplied (xL→x=L,x0→x=0); depth inz - Outline edge (
on_segment+s, §9.2.2) —sdistance along anoutlinesegment or aholewall; depth inz; thex/yposition is determined from the geometry
Edge depth is always in z (from the face) — the x/y axes do not change meaning between edges.
Used in JSON fields: drilling.x, drilling.y, drilling.z, drilling.s, drilling.on_segment
Unit: mm
Milling
JSON equivalent: routing
Definition: A milling operation on a panel. The .meb format describes only the resulting geometry — not the tool or the CAM parameters. Five geometric primitives: slot (a slot swept along a trajectory), outline (outer outline), hole (through cut-out), pocket (pocket), biscuit (biscuit joint).
Used in JSON fields: panel.operations.routings[]
Slot — swept slot
JSON equivalent: slot
Definition: A milling primitive describing the sweep of a constant cross-section along a trajectory. It covers slots on the face, slots/rebates on the edge, roundovers, profiled chamfers, slots for HDF, cornices. Two orthogonal axes: placement — surface (the path field, a trajectory on the face) or edge (edge_side or on_segment, a trajectory along the edge); section — simple (a rectangle width × depth + an optional offset) or profiled (a full profile profile_ref, which defines the entire cut geometry — without offset, the positioning is baked into the profile).
Field value: routing.type: "slot"
Pocket
JSON equivalent: pocket
Definition: Milling of a closed, non-through area on the face of a panel, creating a recess to the depth depth. The pocket outline is always closed (path.closed: true) and does not change the outer shape of the panel — through cut-outs are described by outline/hole. It has a flat bottom and straight walls (profiling of a wall — by a separate slot). It does not support edge banding — banding of walls applies only to outline/hole.
Field value: routing.type: "pocket"
Biscuit — biscuit joint
JSON equivalent: biscuit
Definition: Point milling for a biscuit joint (lamella joint, e.g. Lamello P-10/20). The geometry results from the biscuit size defined in biscuit_catalog. Position of the biscuit axis — the coordinate system is identical to that of drillings (§9.2.1, §9.2.2): in the face x+y, on a base edge x (L/R) or y (T/B) + z, on an outline edge on_segment+s+z. The thickness dimension is distributed symmetrically on both sides of the axis. A biscuit can be milled in an edge (edge_side/on_segment) or in the face (face).
Field value: routing.type: "biscuit"
Profile catalog
Geometric profile
JSON equivalent: profile
Definition: A geometric description of the cross-section of a cut, stored in the profiles[] catalog. It contains only the resulting geometry — no data about the tool or machine parameters. Tool selection is up to the fabricator. Used in type: slot, section: profiled as the full cross-section of the cut. The first point is start (default (0, 0)). Frame: for an edge slot, (0, 0) is at the corner face ∩ edge_side/on_segment (X+ into the material, Y+ into the thickness); for a surface slot, (0, 0) is on the path axis in the face plane (X+ transversely, Y+ into the thickness). Y = 0 is the entry surface — the profile must be open and anchored on it (§11.5.2).
Used in JSON fields: profiles[], routing.profile_ref
Geometric path
JSON equivalent: path
Definition: A description of the geometry of a milling operation or of a geometric profile as an ordered list of segments. It has a starting point (start) and a closing flag (closed). All coordinates are absolute in the local coordinate system of the panel, counted from the bottom-right corner of the face (specification §14.1).
Used in JSON fields: routing.path, profiles[].path
Path segment
JSON equivalent: path segment
Definition: A single element of a geometric path. It begins where the previous segment ended. Three available types:
line— a straight segment to the pointend {x, y}arc— a circular arc described bycenter {x, y},radius,angle_start,angle_end(in degrees) andclockwise(bool). Maps directly to G2/G3 in G-code.bezier— a cubic Bézier curve with the control pointscp1 {x, y},cp2 {x, y}and the end pointend {x, y}
Used in JSON fields: routing.path.segments[], profiles[].path[]
type values: line | arc | bezier
Closed / open path
JSON equivalent: closed path
Definition: The flag closed: true means a closed outline — the last segment connects to the start point. Used for pockets (pocket), through cut-outs (hole) and outer outlines (outline, which describe the finished shape of the panel). closed: false means an open path — used for slots (slot) and edge profiles.
Used in JSON fields: routing.path.closed
Machined segment
JSON equivalent: machined
Definition: A flag of an outline segment marking it as a real cut — the difference between the finished shape and the base rectangle (dimensions). Segments that coincide with the sides of the rectangle (edges of the blank) are not machined. When no segment has an explicit flag, machining is determined geometrically (a segment outside the boundary of the rectangle). It allows the postprocessor and pre_trim/edging to operate only on the actual cut.
Used in JSON fields: routing.path.segments[].machined
Hardware
Hardware item
JSON equivalent: hardware
Definition: An element mounted in a cabinet: a hinge, a drawer runner, a basket, a handle, a leg, a screw, a dowel, a cam lock, etc. A hardware item is counted and ordered through its catalog entry. It is a tree node in any group or at the root: a list entry with a quantity, or a single piece in its place — with a position and simplified geometry, which are solely its appearance.
Used in JSON fields: nodes with type: "hardware"
Hardware catalog
JSON equivalent: hardware_catalog
Definition: A library of the hardware used in the project. Each entry contains: an identifier, the manufacturer's catalog code, a name and the manufacturer's name. Instances in cabinets refer to the catalog via hardware_ref.
Used in JSON fields: hardware_catalog[]
Hardware instance
JSON equivalent: hardware_instance
Definition: A hardware node in the tree. It specifies the type through hardware_ref and the number of pieces through quantity. A hardware item without a position is a list entry in its group (screws in a bag). A hardware item with a position (position) is a single piece in its place: it has a rotation, a material and geometry, and its quantity is 1. Up to version 2.x — an entry in the cabinet.hardware[] list.
Used in JSON fields: nodes with type: "hardware"
Hardware machining operation
JSON equivalent: hardware_instance_ref
Definition: A drilling or milling operation that results from a hardware item with a position and points to it with its field. A hardware item that is deleted or moved takes its machining operations with it. One hardware item can have machining operations on several panels, also in another cabinet — this is also how fasteners are described (confirmat screw, cam lock, dowel).
Used in JSON fields: drilling.hardware_instance_ref, routing.hardware_instance_ref
Production numbering
Production number
JSON equivalent: production_id
Definition: An optional structural identifier of an element, assigned by the design software on export. Format: numeric segments separated by dots — the number of segments corresponds to the depth of the element in the scene graph. Structurally identical elements (the same dimensions, material, machining, edge banding — regardless of the 3D position) receive the same number at their level of the hierarchy.
Used in JSON fields: panel.production_id, node.production_id
Examples: "01.01", "01.02.03", "02.01.01.04"
BOM
JSON equivalent: Bill of Materials
Definition: A list of the materials and elements needed for production — panels (with dimensions and material), edge banding, hardware and tools. Generated by software from the scene graph — the multiplicity of elements results from the number of nodes in the tree. It is not a JSON field in the .meb file; it is an external report generated from the file data.
Comments
Comment
JSON equivalent: comment
Definition: Any text remark assigned to an element of the project. Comments are stored in the global comments[] list and assigned to objects by reference (comment_refs[]). The same comment can be assigned to multiple objects.
Used in JSON fields: comments[]
Comment reference
JSON equivalent: comment_refs
Definition: A list of the identifiers of comments assigned to a given object. Available on tree nodes (group, panel, hardware, solid) and on operations (drilling, routing). Optional field — absence of the field means no comments.
Used in JSON fields: node.comment_refs, drilling.comment_refs, routing.comment_refs