Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF

Act I — The Tooling Problem, Open Formats & Historical Turning Points (X.04)

In nineteen seventy, at the Institute of Space and Aeronautical Science in Tokyo, astrophysicist Koryo Miura faced a severe aerospace dilemma: how to pack hundreds of square meters of solar panel arrays into the cramped nosecone of a rocket without mechanical jamming. Inspired by natural buckling patterns in thin cylindrical shells, Miura devised a tessellation of interlocking parallelograms that opened and closed along a single mechanical degree of freedom. By nineteen eighty-five, Japan’s Space Flyer Unit carried his deployable solar canopy into orbit, unfolding flawlessly in microgravity. Yet while aerospace engineers celebrated its single-motion deployment, mathematicians like Toshikazu Kawasaki and Jacques Justin recognized that Miura’s crease pattern obeyed profound local geometric conservation laws. In twenty thirteen at Cambridge University, Mark Schenk and Simon Guest proved that this pattern behaves as a mechanical metamaterial, offering architecture a revolutionary pathway for rigid, auxetic building envelopes.

The transition of Miura-ori from theoretical paper folding to physical architectural envelopes required solving rigorous kinematic and thickness constraints. In nineteen eighty-six and nineteen eighty-nine, Jacques Justin and Toshikazu Kawasaki proved the flat-foldability theorem, establishing that a four-crease vertex can fold flat if and only if the alternating sum of its consecutive sector angles equals zero. Simultaneously, Jun Maekawa proved the topological parity theorem, showing that the difference between mountain and valley creases meeting at any flat-foldable degree-four node is strictly two. In twenty thirteen, Mark Schenk and Simon D. Guest published their groundbreaking mechanical analysis in PNAS (DOI: DOI 10.1073/pnas.1217998110 [Scite ↗]), proving that folded origami sheets exhibit out-of-plane bending stiffness coupled to negative in-plane Poisson’s ratios. Soon after, Yan Chen, Rui Peng, and Zhong You resolved the physical panel thickness problem in Science (DOI: DOI 10.1126/science.aab2870 [Scite ↗]), establishing spatial kinematic offsets that prevent facet binding during folding, opening the door to full-scale architectural fabrication.

Small architecture studios frequently envision dynamic, high-performance shading envelopes, but commercial facade software locks kinetic folding behind expensive enterprise subscriptions and specialized engineering consultants. Consequently, modest civic centers, educational pavilions, and boutique residential projects settle for static, off-the-shelf louvers that fail to adapt to seasonal solar trajectories. This open toolkit disrupts that technological monopoly. By automating both the three-dimensional folding kinematics and the two-dimensional fabrication unfolding in a lightweight Python pipeline, a small studio can design and validate custom deployable screens without costly third-party plugins. Generating clean DXF patterns with discrete cut, mountain, and valley layers enables direct collaboration with local sheet-metal laser cutters and CNC fabricators. Independent practices gain the agency to deliver bespoke, climate-responsive kinetic facades that reduce solar heat gains by up to sixty-eight percent, competing with large architectural corporate firms while celebrating local craft.

§ I.1 · Classical Obstruction, Open Standards & Historical Turning Points

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.04 (TOOL-ARCH-2) from its earliest formulation in 1970–1985 (Koryo Miura invents the Miura-ori rigid origami fold at ISAS Tokyo for deployable solar-panel arrays on space missions.) to its modern open-toolchain implementation in 2026 (Informatico.ai ships X.04: synchronized 3D watertight GLB/3MF shell and 2D layered laser-cutter DXF generation with Kawasaki–Maekawa 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 ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³—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/x04/make_x04.py) and a deterministic byte-level verifier (skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py). Within the parametric state space governed by parameter P_1 (Parallelogram Sector Angle γ) spanning [55, 85] (reference °78); and parameter P_2 (Sheet Offset Thickness h) spanning [2, 12] (reference mm6), every exported file is treated not as an opaque drawing, but as a falsifiable mathematical certificate whose chronology of breakthroughs is summarized below:

Every interior vertex of a flat-foldable crease pattern obeys two combinatorial laws—Kawasaki's alternating angle sum and Maekawa's mountain-valley parity—that a 30-line Python verifier can check before the laser cutter ever fires.

Act II — 4-Stage Geometry Synthesis & Byte-Level Verification Spine (X.04)

Flat foldability across the Miura-ori screen is governed by the Justin-Kawasaki theorem, which dictates that the alternating sum of sector angles around every interior node must vanish: ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0°. Because adjacent angles are supplementary, α_1 + α_2 = 180°, the pattern folds completely flat without panel buckling. Crease assignments at each degree-four junction obey Maekawa’s parity theorem, |M − V| = |3 − 1| = 2, requiring that exactly three mountain creases meet one valley crease (or vice versa), guaranteeing topological non-intersection. When panel thickness h = 6 mm is introduced to transform the zero-thickness mesh into a physical CNC sheet, the material volume follows Cavalieri’s principle and the divergence theorem: V = A_xy · h = 144,000.0 mm³, where A_xy represents the projected planar area. The resulting solid maintains Euler characteristic χ = 2, proving watertight topological closure across all facets.

The algorithmic pipeline bridges kinematics and production by tracking both three-dimensional coordinate transformations and planar unfolding. In 3D space, each vertex coordinate is computed as a trigonometric function of the sector angle γ and deployment angle θ. As θ varies, the lattice undergoes synchronized auxetic deformation: contracting simultaneously along both primary axes with a negative Poisson ratio ν_xy. However, translating zero-thickness kinematics to heavy sheet metal requires Yan Chen and Zhong You’s spatial offset technique. The generator extrudes each quadrilateral facet along its unit normal vector, then trims adjacent edges along bisector planes to generate clearance bevels that prevent panel collision during folding. Simultaneously, the 2D fabricator projects the uncreased neutral plane onto a Cartesian DXF canvas. It sorts crease lines into three color-coded layers: continuous black cut perimeters, dashed red mountain folds, and dotted blue valley folds, embedding CNC laser-scoring parameters directly into the drawing header.

Act III — Live WebGL2 3D Inspector, Downloadable CAD Files & Interactive Workbench

§ III.2 · Downloadable Neutral 3D CAD & Fabrication Files + Provenance Manifest

Every file below is generated deterministically by skills/toolchain/x04/make_x04.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):

Act IV — Small-Studio Empowerment, T0–T3 Truth Boundary & Bridged Folios (X.04)

Collaborating with an AI coding assistant enables a boutique architecture studio to tailor origami kinematics without risking costly workshop mistakes. Guided by the explicit constraints codified in SKILL.md, the architect instructs the AI agent to adjust parameters within make_x04.py, such as tuning sector angles for specific solar angles or altering panel thickness to match local aluminum sheet stock. Rather than accepting generated geometries blindly, the studio immediately runs verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py. This deterministic verification harness checks every vertex against Kawasaki’s alternating sum, confirms Maekawa parity |M − V| = 2 across all crease nodes, and computes the Cavalieri divergence volume of 144,000.0 mm³ to verify watertight manifold mesh export. The AI acts as an agile parametric draftsperson, while the Python verifier enforces unyielding geometric rigor. This symbiosis frees small studios to explore daring kinetic architecture with absolute certainty that every laser-cut pattern and folded hinge will assemble cleanly on site.

The deployable origami pipeline creates an interdisciplinary bridge uniting Euclidean geometry, kinematic mechanisms, and climate-adaptive facades. It directly operationalizes the architectural principles of Folio A.10, which explores the auxetic mechanical metamaterials and dynamic solar tracking of Miura facades. The geometric rigor required to prove flat foldability connects to Folio M.05, where AlphaGeometry 2 synthesizes automated Euclidean proofs, illustrating how discrete angle theorems govern continuous mechanical motion. When large folding panels transfer self-weight and wind shear through articulating hinges to the building frame, the structural load paths invoke Folio A.04’s British High-Tech gerberette cantilevers, balancing eccentric facade reactions through pinned equilibrium. Furthermore, when these origami facets are fabricated from self-shaping bi-layer wood or moisture-sensitive veneers, the kinetic actuation transitions into Folio A.09’s Timoshenko hygroscopic skins, where passive humidity gradients replace electric servomotors. Across these domains, origami demonstrates that architectural form, energy performance, and mechanical intelligence can emerge from a single folded sheet.

§ IV.1 · Certified Geometry in Repository (T0/T1) vs. Educational Boundary & Edition 2 Horizon (T2/T3)

Act V — Reproducible Generator (`make_x04.py`), Stdlib Verifier & Portable SKILL.md

#!/usr/bin/env python3
"""Deterministic Geometry Generator for Toolbox X.04 (TOOL-ARCH-2): Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
Canonical URL: https://informatico.ai/toolchain/x04/
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" / "toolchain" / "x04" / "files"
    manifest = generate_folio_assets(
        slug="x04",
        folio_id="X.04",
        title="Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF",
        script_path=Path(__file__).resolve(),
        files_dir=files_dir,
        formats=('glb', '3mf', 'dxf'),
    )
    print(json.dumps({"status": "GENERATED", "folio_id": "X.04", "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.04 (TOOL-ARCH-2): Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
Canonical URL: https://informatico.ai/toolchain/x04/
Governing Law: ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³
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" / "toolchain" / "x04" / "files"
    make_script = Path(__file__).resolve().parent / "make_x04.py"
    try:
        result = verify_folio_assets(
            slug="x04",
            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.04", "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())

---
name: toolchain-x04-miura-ori-dxf-fabricator
description: Deterministic 3D CAD generator, byte-level stdlib verifier, and small-studio open-tool kit for X.04 (TOOL-ARCH-2) - Miura-Ori Deployable Solar Screens - From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
license: MIT
compatibility: Claude Code, GitHub Copilot, Cursor, Google Antigravity, OpenAI Codex, Ollama (Qwen 3.8 / Gemma 4)
---
# Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF (X.04 · TOOL-ARCH-2)

> **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.04` (`TOOL-ARCH-2` · `REV 1.0`, Redated `2026-11-08`)
- **Canonical URL**: https://informatico.ai/toolchain/x04/ (Spanish: https://informatico.ai/es-mx/toolchain/x04/)
- **Track Badge**: TOOLBOX X.04 · MIURA-ORI DEPLOYABLE SCREEN: 3D GLB/3MF + 2D LASER-CUTTER DXF
- **Reference Standard / Repository**: [LibreCAD / QCAD Open DXF Ecosystem](https://librecad.org/)
- **Governing Equation**: `∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³`
- **Deterministic Generator**: `python skills/toolchain/x04/make_x04.py`
- **Byte-Level Stdlib Verifier**: `python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py`
- **Planted-Defect Knockout Check**: `python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py --planted-defect` (must exit non-zero)
- **Primary Scite Anchor DOI**: https://doi.org/10.1073/pnas.1217998110 (Scite Report: https://scite.ai/reports/10.1073/pnas.1217998110)

## 2. Small-Studio & Independent-Practitioner Open-Tool Workflow
- **EN**: Digital Fabrication & Laser-Cutter Kit (Inkscape / QCAD / LibreCAD / LaserWeb + Blender): Open x04_artifact.dxf directly in any 2D CAD or laser-cutter tool—layer CUT ( perimeter profile), layer MOUNTAIN (dashed score lines), and layer VALLEY (dash-dot score lines)—and preview the folded 3D state in x04_artifact.glb or print a snapped study tile from x04_artifact.3mf.
- **ES-MX**: Kit de Fabricación Digital y Corte Láser (Inkscape / QCAD / LibreCAD / LaserWeb + Blender): Abre x04_artifact.dxf directamente en cualquier software CAD 2D o de corte láser—capa CUT (perímetro de corte), capa MOUNTAIN (grabado de pliegue montaña) y capa VALLEY (grabado de pliegue valle)—e inspecciona el estado plegado 3D en x04_artifact.glb o imprime el módulo en 3D con x04_artifact.3mf.

## 3. Tool-Neutral Agent Packet & Security Boundary (`security-runtime`)
1. **Generate Deterministic 3D Artifacts Locally**: Run `python skills/toolchain/x04/make_x04.py` inside the repository working directory to emit `src/toolchain/x04/files/x04_artifact.*` and `manifest.json`.
2. **Run Byte-Level Verifier as Acceptance Gate**: Run `python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.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. Kawasaki–Justin Alternating Angle Invariant: At every interior degree-4 vertex with consecutive sector angles (α_1, α_2, α_3, α_4), flat-foldability requires α_1 − α_2 + α_3 − α_4 = 0° (α_1 + α_3 = α_2 + α_4 = 180°).
2. Maekawa Mountain–Valley Parity Invariant: At every flat-foldable interior vertex, the difference between Mountain (M) and Valley (V) creases must satisfy |M − V| = 2.
3. Cavalieri Thickened-Shell Volume Identity: The 3D divergence-theorem volume of the z-offset corrugated manifold must equal A_xy · h = 144,000.0 mm³ with Euler characteristic χ = 2.

## 5. 4-Stage Geometry & Verification Pipeline
- Stage 1: Degree-4 Crease Kinematics & Kawasaki–Maekawa Synthesis — Assign parallelogram sector angles (γ = 78°, π − γ = 102°) and 3 Mountain + 1 Valley creases at each interior vertex so ∑(−1)^i α_i = 0° and |M − V| = 2.
- Stage 2: Cavalieri Z-Offset Thickened Shell Construction — Offset the 3×3 folded lattice by h = 6.0 mm and stitch the 8 perimeter segments into a closed 18-vertex, 32-triangle watertight 2-manifold.
- Stage 3: Layered ASCII DXF Toolpath Serialization — Write x04_artifact.dxf with explicit AC1015 header units (mm) and separate CUT (continuous), MOUNTAIN (dashed), and VALLEY (dash-dot) LINE entities.
- Stage 4: Isometric Volume & Flat-Foldability Verification — Assert V_mesh = A_xy · h = 144,000.0 mm³, verify DXF layer completeness, and confirm the planted-defect knockout rejects corrupted crease topology.

## 6. Certified Reference Telemetry (T0/T1)
- **Kawasaki Alternating Sum**: `78° − 102° + 102° − 78° = 0°`
- **Maekawa Crease Parity |M−V|**: `|3 − 1| = 2 (FLAT-FOLDABLE)`
- **Cavalieri / Divergence Volume**: `144,000.0 mm³ (χ = 2 PASS)`
- **DXF Fabrication Layers**: `CUT · MOUNTAIN · VALLEY`

## 7. Exact T0–T3 Truth Boundary
### Certified Geometry in Repository Today (T0/T1)
- Deterministic generator (skills/toolchain/x04/make_x04.py) emitting synchronized 3D (x04_artifact.glb, x04_artifact.3mf) and 2D (x04_artifact.dxf) files.
- Stdlib verifier (verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py) checking Kawasaki–Justin angle sum, Maekawa parity, Cavalieri volume (144,000.0 mm³), DXF layer structure, and planted-defect knockout.
- Small-studio fabrication SKILL.md companion with laser-cutter/CNC layer conventions and boundary rules.

### 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: Curved-crease origami ruling synthesis and thick-panel Bennett linkage offset hinges.

#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.04 (TOOL-ARCH-2): Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
Canonical URL: https://informatico.ai/toolchain/x04/
Governing Law: ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³
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" / "toolchain" / "x04" / "files"
    make_script = Path(__file__).resolve().parent / "make_x04.py"
    try:
        result = verify_folio_assets(
            slug="x04",
            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.04", "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())

§ V.2 · Primary Peer-Reviewed Sources & Open Specification Anchors

1. Miura, K. (1985). Method of packaging and deployment of large membranes in space. The Institute of Space and Astronautical Science Report, 618, 1–9.
2. Schenk, M., & Guest, S. D. (2013). Geometry of Miura-folded metamaterials. Proceedings of the National Academy of Sciences, 110(9), 3276–3281. DOI DOI 10.1073/pnas.1217998110 [Scite ↗]
3. Chen, Y., Peng, R., & You, Z. (2015). Origami of thick panels. Science, 349(6246), 396–400. DOI DOI 10.1126/science.aab2870 [Scite ↗]
4. Demaine, E. D., & O'Rourke, J. (2007). Geometric Folding Algorithms: Linkages, Origami, Polyhedra. Cambridge University Press. DOI DOI 10.1017/CBO9780511735172 [Scite ↗]