Additive & Structural Toolbox · SIMP Lattices to Watertight 3MF · X.05 (TOOL-FAB-1) · 22 min read
How to convert variable-density SIMP structural struts into guaranteed 2-manifold 3MF and GLB meshes while auditing frustum volume conservation and build-plate overhang angles θ = arccos(−n · ẑ) in pure Python.
When engineers and makers run topology optimization (like the Bendsøe–Sigmund SIMP method in Folio E.11), raw voxel density fields often turn into jagged, non-manifold marching-cubes meshes that choke CAD kernels and slicers. Constructing tapered structural struts directly as closed 2-manifold frustums—and auditing their exact volume and overhang angles before export—bridges mathematical optimization and clean 3MF/STEP files without ever making unverified fitness claims.
Download the committed, SHA-256-verified 3D mesh, STEP solid, 3MF print package, or DXF cut sheet directly:
Open .glb in Blender 4.2+ (File → Import → glTF 2.0), .step in FreeCAD 1.0 or build123d / CadQuery, .3mf in OrcaSlicer / PrusaSlicer, or .dxf in QCAD Community Edition / LibreCAD / Inkscape.
Run python skills/toolchain/x05/make_x05.py to generate custom dimensions and python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py to verify watertightness in <1s.
skills/toolchain/x05/make_x05.py below.
Actos I y II — Historia, ley geométrica e intuición cotidiana: Puntales Estructurales Optimizados por Topología a 3MF Hermético y Auditoría de Voladizo — Cómo convertir puntales estructurales SIMP de densidad variable en mallas 3MF y GLB 2-variedad garantizadas auditando la conservación de volumen de tronco piramidal y los ángulos de voladizo θ = arccos(−n · ẑ) en Python puro. Este monográfico interactivo verifica la ley geométrica V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45°. Por qué importa en el estudio y taller: Cuando ingenieros y makers ejecutan optimización topológica (como el método SIMP de Bendsøe–Sigmund del Folio E.11), los campos de densidad de vóxeles suelen producir mallas escalonadas y no-variedad que fallan en los programas CAD y laminadores. Construir puntales ahusados directamente como troncos cerrados 2-variedad—y auditar su volumen exacto y ángulos de voladizo antes de exportar—conecta la optimización matemática con archivos 3MF/STEP limpios sin hacer afirmaciones infundadas de aptitud.
En Palabras Sencillas (Explicación Accesible): Diseñar piezas mecánicas ultraligeras y resistentes suele enfrentar a ingenieros y creadores con modelos digitales defectuosos que fallan al momento de fabricarse. Cuando los programas de optimización eliminan material sobrante para dejar puntales delgados parecidos a huesos, las mallas resultantes suelen contener agujeros, caras invertidas y grietas microscópicas. Este entorno interactivo genera puntales estructurales de sección variable garantizando cuerpos sólidos herméticos sin un solo error topológico. Desde su navegador, ustedes pueden ajustar las dimensiones del puntal en tiempo real, auditar el volumen exacto de material necesario y verificar que las paredes nunca se inclinen tanto como para requerir soportes temporales que desperdicien filamento o resina. Una vez aprobada la geometría, pueden descargar inmediatamente los archivos de producción en formatos 3MF, GLB o STEP. Estos modelos se abren de forma directa en OrcaSlicer, PrusaSlicer, FreeCAD o Blender, listos para mandarse a la impresora sin necesidad de reparaciones adicionales.
Mecanismo Técnico, Fuerzas en Competencia y Umbral Crítico: La síntesis matemática de este puntal estructural asegura una correspondencia estricta entre la topología combinatoria y la cinemática de manufactura aditiva. El volumen total del componente se calcula mediante la fórmula clásica del tronco piramidal para sus tres secciones apiladas: V = ∑ (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)), conservando un valor exacto de 46,080.0 mm³ sin pérdidas por discretización numérica. La orientación superficial se audita mediante el ángulo de voladizo respecto al vector de construcción descendente, donde la inclinación de pared θ = arctan(Δw / Δz) resulta en 14.04°, manteniéndose holgadamente por debajo del umbral crítico de 45.0°. Simultáneamente, la estructura de semi-aristas verifica el cierre 2-variedad bajo la característica de Euler–Poincaré χ = V − E + F = 2 y la condición de frontera cerrada 2E = 3F. Esta validación analítica garantiza que los archivos 3MF y STEP exportados mantengan propiedades físicas verificables para simulaciones mecánicas posteriores.
Acto III — Visor 3D WebGL2 y Archivos CAD Descargables: el inspector 3D en vivo y los archivos neutrales descargables (.glb, .step, .3mf, .dxf) te permiten inspeccionar la malla, hacer cortes transversales y probar el modo de defecto plantado directamente en el navegador.
Actos IV y V — Kit para pequeños estudios, generador en Python y fuentes: descarga skills/toolchain/x05/make_x05.py, skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py y SKILL.md. Cálculo educativo y exploratorio únicamente, no un diseño estructural firmado.
Designing high-strength lightweight parts often leaves makers and engineers wrestling with messy digital meshes that refuse to print or import cleanly. When computer optimization carves away unnecessary material to leave slender bone-like struts, the resulting digital models frequently contain broken edges, holes, and microscopic cracks. This browser workbench takes variable-density structural struts and builds them directly as clean, watertight solid bodies with mathematically guaranteed outer skins. You can examine every junction live in your browser, audit the exact volume of metal or plastic required, and ensure the side walls never lean so steeply that a three-dimensional printer requires wasteful temporary support structures. Once your design passes every geometric check, you can instantly download production-ready files in modern 3D Manufacturing Format, standard GL Transmission Format, or neutral STEP boundary representations. You can immediately drag these files into OrcaSlicer, PrusaSlicer, FreeCAD, or Blender without repairing a single broken triangle.
Nearly 3,850 years ago, an Egyptian scribe on Problem 14 of the Moscow Mathematical Papyrus (c. 1850 BCE) wrote down the exact formula for the volume of a tapered square frustum: V = (h/3)(a² + ab + b²). In 1904, Australian engineer Anthony George Maldon Michell proved that minimum-weight structural frames follow smooth, bone-like principal strain curves rather than boxy beams.
Between 1988 and 2001, Martin Bendsøe and Ole Sigmund turned Michell’s dream into the SIMP topology optimization algorithm. Yet raw voxel outputs from topology optimization often produce jagged, non-manifold meshes that fail in CAD and slicers. By synthesizing tapered structural struts directly as closed 2-manifold frustums—and auditing both their exact Moscow-Papyrus volume and facet overhang angles θ = arccos(−n · ẑ) ≤ 45°—Folio X.05 delivers clean 3MF, GLB, and STEP geometry.
Problem 14 derives V = (h/3)(A₁ + A₂ + √(A₁A₂)) for a truncated pyramid—the exact volume invariant used in Stage 3.
Classical Roadblock: Applied to stone monuments rather than arbitrary 3D triangle meshes.Derives analytical minimum-volume structural layouts along orthogonal lines of principal strain.
Classical Roadblock: Organic tapered struts were nearly impossible to machine by hand.Publishes the Solid Isotropic Material with Penalization method (DOI 10.1007/s001580050176) for automated load-path carving.
Classical Roadblock: Marching-cubes voxel extraction often creates non-manifold holes.Establishes guaranteed 2-manifold mesh kernels (elalish/manifold) and deterministic XML/ZIP 3MF manufacturing packages.
Classical Roadblock: Overhang angles θ > 45° still require geometric pre-screening before slicing.Certifies V = 46,080 mm³ frustum identity, 3F = 2E closure, θ_max = 14.04° ≤ 45°, and deterministic 3MF/GLB/STEP export.
Classical Roadblock: Geometry check only; actual printability depends on material and machine.In the dry heat of Melbourne in 1904, the Australian mechanical theorist Anthony George Maldon Michell sat at his drafting table sketching the ultimate theoretical boundaries of structural economy. Michell calculated that the lightest possible frameworks capable of carrying external loads without buckling must follow intersecting lines of principal strain, forming orthogonal curves reminiscent of organic bone tissue. For nearly a century, Michell's elegant mathematical networks remained largely theoretical dreams because foundry workers and machinists could not easily carve such intricate, curved trusses from solid ingots. That craft dilemma began to dissolve in Copenhagen during the late 1980s, when Martin Bendsøe and Ole Sigmund pioneered the solid isotropic material with penalization method. By allowing computer algorithms to continuously redistribute material density across thousands of simulated finite elements, structural engineers could watch computer screens carve organic load paths automatically.
Yet converting continuous density fields into physical hardware introduced a fresh computational barrier. When algorithms filtered gray intermediate voxels into crisp binary boundaries, standard isosurface extraction methods like marching cubes produced jagged, non-manifold surfaces riddled with self-intersections and unstitched edges. In their foundational review (Bendsøe & Sigmund, Structural and Multidisciplinary Optimization, DOI DOI 10.1007/s001580050176 [Scite ↗]), the researchers emphasized that mathematical convergence in an idealized finite-element grid does not guarantee physical manufacturability on factory floors. To bridge this divide, computer graphics engineers such as Emmett Lalish developed rigorous boundary-representation algorithms, proving that constructive solid geometry could maintain strict manifold topology without floating-point leaks. Simultaneously, the 3MF Consortium established Core Specification v1.2.3, replacing fragile legacy STL formats with structured XML archives containing verifiable vertex indices, unit definitions, and build-space orientations. Modern computational pipelines now enforce closed-volume invariants directly during lattice synthesis, generating certified structural components that import into slicing engines without repair.
For solo engineers, independent aerospace consultancies, and digital fabrication ateliers, the gap between mathematical design and print-bed reality carries punishing financial consequences. When a prototype mesh contains non-manifold seams or invalid facet orientations, slicing software either aborts or silently generates erratic toolpaths that deposit stray filament into mid-air voids. On expensive metal laser powder-bed fusion systems or industrial photopolymer printers, a single geometric failure causes recoater blade collisions, warped build plates, and thousands of dollars in wasted feedstock and machine downtime. Furthermore, excessive downward-facing overhang angles force slicers to generate dense internal support forests that require tedious manual post-processing and ruin delicate surface finishes. By executing rigorous topological and overhang audits inside lightweight client environments before sending geometry to the printer, independent teams bypass expensive enterprise modeling suites. They produce certified, support-free structural struts that transition seamlessly from algorithmic conception to flawless physical inspection on the factory floor.
Independent Structural & Maker Stack (Manifold Apache-2.0 + OrcaSlicer / PrusaSlicer + FreeCAD): Generate variable-taper structural struts in Python, export x05_artifact.3mf with embedded XML metadata and x05_artifact.step, and run verify_x05 to audit 2E = 3F watertightness, frustum volume, and wall overhang angle distribution.
Every enduring engineering and architectural tool begins as a human effort to turn tacit workshop craft into an inspectable, shareable language. Tracing the evolution of Toolbox X.05 (TOOL-FAB-1) from its earliest formulation in 1904 (A. G. M. Michell derives the analytical minimum-weight truss layouts (Michell continua) along orthogonal principal strain lines.) to its modern open-toolchain implementation in 2026 (Informatico.ai ships X.05: tapered frustum manifold synthesis to 3MF/GLB/STEP with divergence-volume and overhang-angle verification.) reveals why closed binary formats and unverified polygon exports repeatedly stalled small practices. Whenever a studio or fabricator is forced to exchange geometry without an explicit mathematical invariant—here governed by V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45°—silent topological defects such as boundary cracks, flipped face normals, or missing clearance tolerances corrupt the handoff between design and physical making.
Resolving that bottleneck requires pairing neutral, royalty-free file specifications (.glb, .step AP242, .3mf, .dxf) with a zero-dependency code generator (skills/toolchain/x05/make_x05.py) and a deterministic byte-level verifier (skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py). Within the parametric state space governed by parameter P_1 (Mid-Span Waist Width w_2) spanning [12, 36] (reference mm24); and parameter P_2 (Upper Head Flare Δw_top) spanning [0, 24] (reference mm4), every exported file is treated not as an opaque drawing, but as a falsifiable mathematical certificate whose chronology of breakthroughs is summarized below:
| Year | Milestone & Verification Anchor |
|---|---|
| 1904 | A. G. M. Michell derives the analytical minimum-weight truss layouts (Michell continua) along orthogonal principal strain lines. |
| 1988–2001 | Martin Bendsøe and Ole Sigmund formulate the SIMP method and publish the famous 99-line topology optimization code (DOI DOI 10.1007/s001580050176 [Scite ↗]). |
| 2015–2023 | The 3MF Consortium standardizes XML/ZIP mesh and beam-lattice representations with explicit unit and provenance metadata. |
| 2026 | Informatico.ai ships X.05: tapered frustum manifold synthesis to 3MF/GLB/STEP with divergence-volume and overhang-angle verification. |
Checking whether a mesh is watertight (3F = 2E) and measuring its facet overhang angle θ = arccos(−n · ẑ) are pure theorems of Euclidean geometry; certifying a physical part requires material testing that no software script can replace.
Everyday Analogy: Think of how an old oak tree tapers smoothly from its wide root collar to a slender waist before flaring out to cradle heavy branches. The trunk stays upright because its outer bark forms an unbroken, sealed boundary enclosing solid wood, and every flare expands at a gentle, self-supporting tilt. In stone masonry, builders stack brick corbels outwards layer by layer to form cantilevered arches. As long as each step angles outward by less than forty-five degrees from vertical, gravity holds the stone securely without temporary wooden falsework collapsing beneath it.
How the Two Sliders & Knockout Work in Plain Words: You can sculpt and verify this structural strut using two interactive sliders and a diagnostic stress-test button. The first control sets the Mid-Span Waist Width, adjusting the strut's narrowest middle cross-section between twelve and thirty-six millimeters. Increasing this dimension bulks up the central core to resist lateral buckling, while narrowing it creates an hourglass silhouette that cuts unnecessary mass. The second control governs the Upper Head Flare, adjusting how far the top mounting flange widens past the base between zero and twenty-four millimeters to distribute joint loads across bolted machine frames. Finally, clicking the Counterfactual Axiom-Knockout button deliberately stresses the strut beyond its safe manufacturing limits. It widens the upper head flare past sixteen millimeters until the lateral wall slope exceeds forty-five degrees, or deliberately flips an outward-facing surface normal. The audit immediately turns red, demonstrating how automated checks reject defective, unprintable geometry before any material reaches a machine.
Stack plastic bricks upward on your desk to build a flared pillar that gets wider near the top. If each new layer steps outward by only 4 mm over a 16 mm vertical rise, the wall leans outward at θ = arctan(4 / 16) = 14.04°—well inside the classic 45° self-supporting corbel angle.
Now drag the Upper Head Flare slider (Δw_top) past 16 mm—say to 20 mm over that same 16 mm height. Suddenly the horizontal step (20 mm) is wider than the vertical rise (16 mm), pushing the overhang angle to arctan(20 / 16) = 51.34° > 45°! Our verifier flags that exact geometric threshold in real time.
Exact solid geometry requires simultaneous adherence to combinatorial topology and classical volume integration. The overall strut volume obeys the ancient Moscow Papyrus frustum summation across its three stacked segments: V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)), yielding exactly 46,080.0 mm³ with zero numerical divergence. Simultaneously, discrete surface orientation is governed by the downward wall overhang angle θ = arccos(−n · ẑ) = arctan(Δw / Δz). At the baseline configuration, this angle evaluates to 14.04°, safely below the critical 45.0° manufacturing limit where additive slicing algorithms mandate sacrificial support structures. To ensure the mesh is a valid watertight solid, the boundary representation must satisfy two-manifold Euler–Poincaré closure χ = V − E + F = 16 − 42 + 28 = 2, where every shared edge connects exactly two adjacent triangular facets (2E = 3F). If an outward normal flips or an edge unzips, the topological invariant corrupts, instantly triggering an automated failure gate.
Live parameter coupling: 24 mm
and 4 mm
under governing law V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45°.
Behind the clean visual preview lies a rigorous computational pipeline operating entirely in standard Python. Rather than approximating organic struts with heavy voxel grids, the generator computes parametric cross-sectional lofts that directly synthesize half-edge triangle topology. Surface normals are calculated analytically from facet cross products and oriented strictly outward via counter-clockwise vertex winding. The overhang audit evaluates the inner product between each normalized facet normal n and the downward unit build vector −ẑ. When the resulting inclination θ = arccos(−n · ẑ) exceeds the critical self-supporting threshold of 45°, liquid resin or molten filament droops under gravity unless pinned by costly support pillars. Concurrently, exact mesh volume is computed using the discrete divergence theorem by summing oriented tetrahedral signed volumes 1/6 (v0 · (v1 × v2)) across all twenty-eight facets. Comparing this signed sum against the analytical Moscow Papyrus frustum formula confirms absolute geometric fidelity, guaranteeing that subsequent structural FEA simulations receive exact volumetric mass distributions.
V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45°
In Toolbox X.05 (Topology-Optimized Structural Struts to Watertight 3MF & Build-Plate Overhang Audit), source of truth is code (skills/toolchain/x05/make_x05.py), never an unverified binary blob. Let the parametric family be governed by parameter P_1 (Mid-Span Waist Width w_2) spanning [12, 36] (reference mm24); and parameter P_2 (Upper Head Flare Δw_top) spanning [0, 24] (reference mm4). The generator emits deterministic, spec-compliant neutral files while the stdlib verifier skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py checks binary chunk bounds, edge-manifold watertightness, divergence-theorem signed volume, bounding box, and SHA-256 manifest hashes.
By expressing the geometry over a well-posed state manifold rather than a brittle history tree of manual GUI clicks, any small studio or independent engineer can audit the exact mapping from input parameters to vertex coordinates, B-Rep face loops, and 2D cutting polylines. Every coordinate is bounded, finite, and reproducible to the byte across Windows, macOS, and Linux.
Rather than treating V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45° as an opaque black box, we decompose the geometry generation and byte-level verification of Toolbox X.05 into four explicit, inspectable stages. True engineering and architectural tools do not ask for blind trust; they invite inspection at every step:
Formal Stage Mechanism: Stage 1: Multi-Station Tapered Strut Parameterization — Define 4 cross-sectional rings along z ∈ {0, 16, 32, 48} mm with half-widths hw ∈ {20, 16, 12, 16} mm.
Byte-Level Invariant Closure: At Stage 1 of Toolbox X.05 (TOOL-FAB-1), the generator skills/toolchain/x05/make_x05.py and stdlib verifier skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py enforce the governing geometric law V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45° along with the companion invariant: Frustum-to-Divergence Volume Identity: The divergence-theorem volume of the triangulated strut must equal the analytical sum of frustum volumes ∑ (h_k/3)(A_{k-1} + A_k + √(A_{k-1}A_k)) = 46,080.0 mm³.
Small-Studio & Free-Tool Verification: When a designer, architect, or independent engineer inspects Stage 1 inside Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer, or QCAD / LibreCAD—or executes python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py on the command line—this stage guarantees that no unverified coordinate drift, inverted surface normal, non-manifold edge seam, or truncated binary chunk can propagate silently into downstream visualization, structural coordination, or digital fabrication workflows. Every output file in src/research/toolchain/x05/files/ is locked by a deterministic SHA-256 hash in manifest.json so small studios can audit exact geometric provenance without any paid proprietary CAD seat.
Formal Stage Mechanism: Stage 2: Closed 2-Manifold Frustum Triangulation — Connect consecutive rings with outward CCW side quads (2 triangles per side) and seal the z = 0 base and z = 48 crown into a 16-vertex, 28-triangle genus-0 manifold.
Byte-Level Invariant Closure: At Stage 2 of Toolbox X.05 (TOOL-FAB-1), the generator skills/toolchain/x05/make_x05.py and stdlib verifier skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py enforce the governing geometric law V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45° along with the companion invariant: Geometric Overhang Angle Bound: Every lateral wall facet normal n_f must satisfy θ_f = arccos(−n_f · ẑ) ≤ 45.0° in the reference benchmark configuration (measured purely as geometry, never as a printability claim).
Small-Studio & Free-Tool Verification: When a designer, architect, or independent engineer inspects Stage 2 inside Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer, or QCAD / LibreCAD—or executes python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py on the command line—this stage guarantees that no unverified coordinate drift, inverted surface normal, non-manifold edge seam, or truncated binary chunk can propagate silently into downstream visualization, structural coordination, or digital fabrication workflows. Every output file in src/research/toolchain/x05/files/ is locked by a deterministic SHA-256 hash in manifest.json so small studios can audit exact geometric provenance without any paid proprietary CAD seat.
Formal Stage Mechanism: Stage 3: Analytical Moscow-Papyrus Frustum Integration — Compute V_exact = ∑_{k=1}^3 (16/3)(A_{k-1} + A_k + √(A_{k-1}A_k)) = 46,080.0 mm³ and verify exact match with the divergence-theorem mesh volume.
Byte-Level Invariant Closure: At Stage 3 of Toolbox X.05 (TOOL-FAB-1), the generator skills/toolchain/x05/make_x05.py and stdlib verifier skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py enforce the governing geometric law V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45° along with the companion invariant: 3MF Package & Planted-Defect Integrity: x05_artifact.3mf must be a valid ZIP archive containing [Content_Types].xml, _rels/.rels, and 3D/3dmodel.model, and verify_x05 must reject any flipped-normal mutation.
Small-Studio & Free-Tool Verification: When a designer, architect, or independent engineer inspects Stage 3 inside Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer, or QCAD / LibreCAD—or executes python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py on the command line—this stage guarantees that no unverified coordinate drift, inverted surface normal, non-manifold edge seam, or truncated binary chunk can propagate silently into downstream visualization, structural coordination, or digital fabrication workflows. Every output file in src/research/toolchain/x05/files/ is locked by a deterministic SHA-256 hash in manifest.json so small studios can audit exact geometric provenance without any paid proprietary CAD seat.
Formal Stage Mechanism: Stage 4: Facet Normal Overhang Audit & 3MF Packaging — Evaluate θ_f = arctan(Δhw / Δz) = 14.036° across the flared upper section, package x05_artifact.3mf, .glb, and .step, and run the planted-defect knockout.
Byte-Level Invariant Closure: At Stage 4 of Toolbox X.05 (TOOL-FAB-1), the generator skills/toolchain/x05/make_x05.py and stdlib verifier skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py enforce the governing geometric law V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45° along with the companion invariant: Frustum-to-Divergence Volume Identity: The divergence-theorem volume of the triangulated strut must equal the analytical sum of frustum volumes ∑ (h_k/3)(A_{k-1} + A_k + √(A_{k-1}A_k)) = 46,080.0 mm³.
Small-Studio & Free-Tool Verification: When a designer, architect, or independent engineer inspects Stage 4 inside Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer, or QCAD / LibreCAD—or executes python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py on the command line—this stage guarantees that no unverified coordinate drift, inverted surface normal, non-manifold edge seam, or truncated binary chunk can propagate silently into downstream visualization, structural coordination, or digital fabrication workflows. Every output file in src/research/toolchain/x05/files/ is locked by a deterministic SHA-256 hash in manifest.json so small studios can audit exact geometric provenance without any paid proprietary CAD seat.
Every neutral file and numerical readout in Toolbox X.05 is governed by three machine-checked falsification invariants embedded in toolchain-x05-simp-manifold-3mf-SKILL.md and executed offline by skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py:
skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py against committed binary artifacts in src/research/toolchain/x05/files/.
skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py against committed binary artifacts in src/research/toolchain/x05/files/.
skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py against committed binary artifacts in src/research/toolchain/x05/files/.
Together, Invariants X.05-R1 through X.05-R3 close the verification loop between parametric authoring and neutral CAD exchange. If any parameter edit, mesh export, or AI code modification violates these bounds, the stdlib verifier exits non-zero and names the violated invariant before a single piece of timber, sheet metal, or filament is wasted.
Primary Structural Note (SIDENOTE X.05-A · GEOMETRY VS. PHYSICAL FITNESS BOUNDARY): Measuring an overhang angle θ ≤ 45° or confirming 3F = 2E watertightness only verifies the mathematical mesh. Actual additive manufacturing depends on polymer rheology, layer adhesion, thermal warping, and nozzle diameter.
Secondary Verification Note (SIDENOTE X.05-B · WHY DETERMINISTIC ZIP TIMESTAMPS MATTER FOR 3MF): Standard ZIP writers embed the current wall-clock time into every entry header, causing git status to mark .3mf files dirty on every run. Our write_3mf helper pins ZipInfo.date_time to a fixed constant for byte-for-bit reproducibility.
Why Every Verifier Must Prove It Can Fail: A verification script that always prints PASS is indistinguishable from a rubber stamp. That is why skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py includes an automated planted-defect canary test: it clones the valid geometry in memory, injects the exact topological or kinematic defect described above, and asserts that the verifier rejects the corrupted artifact before certifying the baseline build.
Every file below is generated deterministically by skills/toolchain/x05/make_x05.py and verified byte-for-byte against manifest.json. Click any card to download the neutral artifact and open it directly in 100% Free & Open-Source Software (Blender 4.2+, FreeCAD 1.0, Bonsai BIM, OrcaSlicer, PrusaSlicer, QCAD Community Edition, LibreCAD, Inkscape):
Certified Geometry Regime (X.05) — All 4 stage invariants satisfied (skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py).
Drag either slider above to scale the live 3D WebGL2 mesh in real time, then click any Export button to synthesize a custom-sized .glb, .step, or .dxf file directly in your browser.
To verify the interactive 3D Inspector and Workbench above by hand or inside an automated studio QA pipeline, we evaluate V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45° at the canonical baseline operating point (parameter P_1 (Mid-Span Waist Width w_2) spanning [12, 36] (reference mm24); and parameter P_2 (Upper Head Flare Δw_top) spanning [0, 24] (reference mm4)) on the committed artifacts in src/research/toolchain/x05/files/. The resulting geometric and topological telemetry is certified as follows: 3-Stage Frustum Volume certifies 46,080.0 mm³ (ΔV = 0.00%); 2-Manifold Closure (V, E, F) certifies V=16, E=42, F=28 · χ=2; Max Wall Overhang Angle θ certifies 14.04° ≤ 45.0° (GEOMETRY); 3MF / GLB / STEP Gate certifies PASS · DEFECT REJECTED.
| Geometry / Format Check | Certified Artifact Value | Stdlib Verifier |
|---|---|---|
| 3-Stage Frustum Volume | 46,080.0 mm³ (ΔV = 0.00%) | skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py · PASS |
| 2-Manifold Closure (V, E, F) | V=16, E=42, F=28 · χ=2 | skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py · PASS |
| Max Wall Overhang Angle θ | 14.04° ≤ 45.0° (GEOMETRY) | skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py · PASS |
| 3MF / GLB / STEP Gate | PASS · DEFECT REJECTED | skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py · PASS |
Running python skills/toolchain/x05/make_x05.py followed by python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py from the repository root regenerates every neutral CAD artifact from scratch and executes the complete byte-level and topological assertion suite in under 1 second using only the Python 3.11+ standard library.
Modern structural engineering reaches peak velocity when human domain intuition couples with autonomous AI coding agents governed by deterministic verifiers. Instead of manually clicking through complex commercial CAD menus, a solo engineer instructs an AI partner to parameterize a lightweight strut assembly. The assistant references the formal protocol in the companion SKILL.md document, modifying parameters inside make_x05.py to meet novel aerodynamic or load-bearing requirements. Before any code is committed or files sent to the fabrication lab, the developer executes verify_x05_toolchain_x05_simp_manifold_3mf.py. This independent Python verification script parses the generated 3MF archive, validates its XML namespace headers, confirms 2-manifold edge matching (2E = 3F), recalculates frustum volumes, and guarantees zero overhang violations. By acting as an unyielding mathematical judge, the deterministic script prevents AI hallucinations from contaminating manufacturing pipelines, allowing small independent teams to produce enterprise-grade, certified aerospace components with absolute geometric confidence.
The geometric principles governing this structural strut form an intellectual crossroads uniting civil engineering, high-performance aerodynamics, rheological fabrication, and pure variational mathematics. When structural engineers optimize seismic bracing in Folio E.11 using SIMP algorithms and inerter dampers, the resulting force-density fields map directly onto these tapered frustum geometries to prevent high-frequency mechanical resonance. In high-speed automotive engineering (Folio P.07), identical slender profiles minimize turbulent wake detachment across Formula 1 ground-effect Venturi floor stays. At architectural scales, the overhang angle criteria θ ≤ 45° dictate the layer-by-layer stability of 3D concrete printing (Folio E.10), where wet paste thixotropy and Suiker buckling govern whether a cantilevered wall stands or collapses under its own weight. Furthermore, viewing mass distribution through Benamou–Brenier optimal transport (Folio M.09) reveals that these organic frustum transitions solve dynamic quadratic Wasserstein geodesic paths, channeling stress efficiently from broad structural foundations into compact machine nodes with minimal internal shear dissipation.
Every tool in Tech & Tools · The Toolbox is designed as an operational bridge across the four core pillars of Informatico.ai—connecting formal mathematical invariants and physical conservation laws directly to studio architecture and engineering fabrication. Explore the companion Pillar Folios and open specifications linked to Toolbox X.05 below:
All active runtime components for Toolbox X.05 are audited in skills/toolchain/licenses.json to ensure permissive licensing (MIT, Apache-2.0, MPL-2.0, LGPL-2.1) with zero copyleft contamination in the committed scripts or neutral 3D artifacts.
Below are the complete, unabridged Python 3 scripts that generate and verify Toolbox X.05 (TOOL-FAB-1). Because code is the primary source of truth, you can inspect every equation, vertex buffer, STEP entity, and planted-defect assertion right on this page, or run them locally on your own machine:
#!/usr/bin/env python3
"""Deterministic Geometry Generator for Toolbox X.05 (TOOL-FAB-1): Topology-Optimized Structural Struts to Watertight 3MF & Build-Plate Overhang Audit.
Canonical URL: https://informatico.ai/toolchain/x05/
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import generate_folio_assets # noqa: E402
def main() -> int:
files_dir = ROOT / "src" / "research" / "toolchain" / "x05" / "files"
manifest = generate_folio_assets(
slug="x05",
folio_id="X.05",
title="Topology-Optimized Structural Struts to Watertight 3MF & Build-Plate Overhang Audit",
script_path=Path(__file__).resolve(),
files_dir=files_dir,
formats=('glb', '3mf', 'step'),
)
print(json.dumps({"status": "GENERATED", "folio_id": "X.05", "files": [f["filename"] for f in manifest["files"]]}, indent=2))
return 0
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.05 (TOOL-FAB-1): Topology-Optimized Structural Struts to Watertight 3MF & Build-Plate Overhang Audit.
Canonical URL: https://informatico.ai/toolchain/x05/
Governing Law: V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45°
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import verify_folio_assets # noqa: E402
def main(argv: list[str] | None = None) -> int:
args = argv if argv is not None else sys.argv[1:]
planted_only = "--planted-defect" in args
files_dir = ROOT / "src" / "research" / "toolchain" / "x05" / "files"
make_script = Path(__file__).resolve().parent / "make_x05.py"
try:
result = verify_folio_assets(
slug="x05",
files_dir=files_dir,
script_path=make_script,
planted_defect_only=planted_only,
)
except AssertionError as exc:
print(json.dumps({"status": "FAIL", "folio_id": "X.05", "error": str(exc)}), file=sys.stderr)
return 1
print(json.dumps(result, indent=2, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())
Equip your studio or AI coding agent with the tool-neutral workflow, open-format export rules, and byte-level verifier gate for Toolbox X.05 (TOOL-FAB-1): download toolchain-x05-simp-manifold-3mf-SKILL.md or verify_x05_toolchain_x05_simp_manifold_3mf.py.
SKILL.md source---
name: toolchain-x05-simp-manifold-3mf
description: Deterministic 3D CAD generator, byte-level stdlib verifier, and small-studio open-tool kit for X.05 (TOOL-FAB-1) - Topology-Optimized Structural Struts to Watertight 3MF & Build-Plate Overhang Audit.
license: MIT
compatibility: Claude Code, GitHub Copilot, Cursor, Google Antigravity, OpenAI Codex, Ollama (Qwen 3.8 / Gemma 4)
---
# Topology-Optimized Structural Struts to Watertight 3MF & Build-Plate Overhang Audit (X.05 · TOOL-FAB-1)
> **Fixed Educational Boundary (`EN`):** Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
>
> **Frontera Educativa Fija (`ES-MX`):** Cada archivo en esta página es un artefacto educativo generado por el script que lo acompaña. Nada aquí está certificado como estructural, imprimible, seguro ni apto para ningún propósito. El verificador comprueba la geometría, no la aptitud.
## 1. Governing Law, Open Standard & Canonical URL
- **Toolbox Folio**: `X.05` (`TOOL-FAB-1` · `REV 1.2`, Redated `2026-11-09`)
- **Canonical URL**: https://informatico.ai/toolchain/x05/ (Spanish: https://informatico.ai/es-mx/toolchain/x05/)
- **Track Badge**: TOOLBOX X.05 · SIMP TOPOLOGY LATTICE → MANIFOLD 3MF · GLB · STEP + OVERHANG AUDIT
- **Reference Standard / Repository**: [elalish/manifold (Apache-2.0 Exact Manifold CSG)](https://github.com/elalish/manifold)
- **Governing Equation**: `V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45°`
- **Deterministic Generator**: `python skills/toolchain/x05/make_x05.py`
- **Byte-Level Stdlib Verifier**: `python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py`
- **Planted-Defect Knockout Check**: `python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py --planted-defect` (must exit non-zero)
- **Primary Scite Anchor DOI**: https://doi.org/10.1007/s001580050176 (Scite Report: https://scite.ai/reports/10.1007/s001580050176)
## 2. Small-Studio & Independent-Practitioner Open-Tool Workflow
- **EN**: Independent Structural & Maker Stack (Manifold Apache-2.0 + OrcaSlicer / PrusaSlicer + FreeCAD): Generate variable-taper structural struts in Python, export x05_artifact.3mf with embedded XML metadata and x05_artifact.step, and run verify_x05 to audit 2E = 3F watertightness, frustum volume, and wall overhang angle distribution.
- **ES-MX**: Stack para Ingenieros y Makers Independientes (Manifold Apache-2.0 + OrcaSlicer / PrusaSlicer + FreeCAD): Genera puntales estructurales ahusados en Python, exporta x05_artifact.3mf con metadatos XML y x05_artifact.step, y ejecuta verify_x05 para auditar hermeticidad 2E = 3F, volumen exacto y distribución de ángulos de voladizo.
## 3. Tool-Neutral Agent Packet & Security Boundary (`security-runtime`)
1. **Generate Deterministic 3D Artifacts Locally**: Run `python skills/toolchain/x05/make_x05.py` inside the repository working directory to emit `src/research/toolchain/x05/files/x05_artifact.*` and `manifest.json`.
2. **Run Byte-Level Verifier as Acceptance Gate**: Run `python skills/toolchain/x05/verify_x05_toolchain_x05_simp_manifold_3mf.py` to verify GLB chunk bounds, 2-manifold half-edge pairing (`3F = 2E`), Euler–Poincaré characteristic (`χ = V - E + F`), divergence-theorem signed volume against the analytical formula, SHA-256 manifest match, and planted-defect rejection.
3. **Security Boundary (`security-runtime`)**: Never grant an AI agent or CAD MCP server shell execution, home-directory access, or outbound network scope when inspecting 3D binaries. Restrict file operations strictly to the project workspace directory.
## 4. Deterministic Verification & Falsification Rules
1. Frustum-to-Divergence Volume Identity: The divergence-theorem volume of the triangulated strut must equal the analytical sum of frustum volumes ∑ (h_k/3)(A_{k-1} + A_k + √(A_{k-1}A_k)) = 46,080.0 mm³.
2. Geometric Overhang Angle Bound: Every lateral wall facet normal n_f must satisfy θ_f = arccos(−n_f · ẑ) ≤ 45.0° in the reference benchmark configuration (measured purely as geometry, never as a printability claim).
3. 3MF Package & Planted-Defect Integrity: x05_artifact.3mf must be a valid ZIP archive containing [Content_Types].xml, _rels/.rels, and 3D/3dmodel.model, and verify_x05 must reject any flipped-normal mutation.
## 5. 4-Stage Geometry & Verification Pipeline
- Stage 1: Multi-Station Tapered Strut Parameterization — Define 4 cross-sectional rings along z ∈ {0, 16, 32, 48} mm with half-widths hw ∈ {20, 16, 12, 16} mm.
- Stage 2: Closed 2-Manifold Frustum Triangulation — Connect consecutive rings with outward CCW side quads (2 triangles per side) and seal the z = 0 base and z = 48 crown into a 16-vertex, 28-triangle genus-0 manifold.
- Stage 3: Analytical Moscow-Papyrus Frustum Integration — Compute V_exact = ∑_{k=1}^3 (16/3)(A_{k-1} + A_k + √(A_{k-1}A_k)) = 46,080.0 mm³ and verify exact match with the divergence-theorem mesh volume.
- Stage 4: Facet Normal Overhang Audit & 3MF Packaging — Evaluate θ_f = arctan(Δhw / Δz) = 14.036° across the flared upper section, package x05_artifact.3mf, .glb, and .step, and run the planted-defect knockout.
## 6. Certified Reference Telemetry (T0/T1)
- **3-Stage Frustum Volume**: `46,080.0 mm³ (ΔV = 0.00%)`
- **2-Manifold Closure (V, E, F)**: `V=16, E=42, F=28 · χ=2`
- **Max Wall Overhang Angle θ**: `14.04° ≤ 45.0° (GEOMETRY)`
- **3MF / GLB / STEP Gate**: `PASS · DEFECT REJECTED`
## 7. Exact T0–T3 Truth Boundary
### Certified Geometry in Repository Today (T0/T1)
- Deterministic generator (skills/toolchain/x05/make_x05.py) producing byte-reproducible x05_artifact.3mf, x05_artifact.glb, and x05_artifact.step.
- Stdlib verifier (verify_x05_toolchain_x05_simp_manifold_3mf.py) checking 2-manifold closure (χ = 2), frustum volume conservation (46,080.0 mm³), 3MF XML structure, and planted-defect rejection.
- Portable SKILL.md companion with explicit geometry-only boundary guardrails.
### Educational Boundary & Edition 2 Horizon (T2/T3)
- Educational Geometry Boundary: Every file on this page is an educational artifact; nothing is certified as load-bearing, printable, safe, or fit for any purpose.
- Future Edition 2 Extensions: 3MF Beam Lattice extension (<beamlattice>) export for multi-thousand-strut aerospace and architectural space frames.
#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.05 (TOOL-FAB-1): Topology-Optimized Structural Struts to Watertight 3MF & Build-Plate Overhang Audit.
Canonical URL: https://informatico.ai/toolchain/x05/
Governing Law: V = ∑_{k=1}^3 (h_k / 3)(A_{k-1} + A_k + √(A_{k-1} A_k)) = 46,080 mm³ · θ_wall = arctan(Δw / Δz) = 14.04° ≤ 45°
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import verify_folio_assets # noqa: E402
def main(argv: list[str] | None = None) -> int:
args = argv if argv is not None else sys.argv[1:]
planted_only = "--planted-defect" in args
files_dir = ROOT / "src" / "research" / "toolchain" / "x05" / "files"
make_script = Path(__file__).resolve().parent / "make_x05.py"
try:
result = verify_folio_assets(
slug="x05",
files_dir=files_dir,
script_path=make_script,
planted_defect_only=planted_only,
)
except AssertionError as exc:
print(json.dumps({"status": "FAIL", "folio_id": "X.05", "error": str(exc)}), file=sys.stderr)
return 1
print(json.dumps(result, indent=2, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())