Core 3D Instrument · WebGL2 & Byte-Level Verification · X.01 (TOOL-CORE-1) · 22 min read
How a 300-line zero-dependency ES module parses binary glTF 2.0 (GLB) buffers into raw WebGL2 while a Python stdlib verifier proves edge-manifold watertightness, divergence-theorem volume, and malformed-binary rejection.
Most 3D viewers on the web pull in megabytes of third-party JavaScript and trust whatever binary file they are handed. For independent engineers, small architecture studios, and researchers, knowing why a 3D file is watertight—and inspecting its binary chunks, Euler characteristic, and signed volume without external dependencies—turns black-box CAD files into auditable mathematical objects.
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/x01/make_x01.py to generate custom dimensions and python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py to verify watertightness in <1s.
skills/toolchain/x01/make_x01.py below.
Actos I y II — Historia, ley geométrica e intuición cotidiana: Visor WebGL2 GLB sin Dependencias y Verificador Geométrico 2-Variedad a Nivel de Bytes — Cómo un módulo ES sin dependencias analiza archivos binarios glTF 2.0 (GLB) en WebGL2 puro mientras un verificador en Python stdlib demuestra hermeticidad 2-variedad, volumen por el teorema de la divergencia y rechazo de binarios corruptos. Este monográfico interactivo verifica la ley geométrica V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E. Por qué importa en el estudio y taller: La mayoría de los visores 3D web descargan megabytes de librerías externas y confían ciegamente en cualquier archivo binario. Para ingenieros independientes, pequeños despachos de arquitectura e investigadores, verificar por qué una malla es hermética—e inspeccionar sus bloques binarios, característica de Euler y volumen con signo sin dependencias—convierte archivos CAD opacos en objetos matemáticos auditables.
En Palabras Sencillas (Explicación Accesible): Para entender una malla tridimensional de forma sencilla, imaginen un balón de fútbol armado con parches de cuero cosidos a mano. Para que el balón retenga el aire y no se desinfle, cada costura debe unir exactamente dos paneles adyacentes, sin dejar ningún orificio abierto y sin amontonar telas. Además, todos los parches deben mirar hacia afuera con el lado liso al exterior. En el diseño digital ocurre exactamente lo mismo: un modelo tridimensional está compuesto por pequeños triángulos planos que deben formar una cáscara perfectamente sellada. Con frecuencia, cuando exportamos archivos entre diferentes programas de diseño, algunas caras se voltean hacia adentro o quedan pequeñas grietas invisibles en la pantalla. Este visor gratuito en el navegador web les permite abrir y girar piezas en tres dimensiones directamente, inspeccionar cortes transversales y comprobar que cada triángulo esté bien colocado. Con un solo clic, cualquier estudiante, diseñador o taller independiente puede descargar modelos verificados y rutinas en Python para revisar sus geometrías sin gastar en licencias costosas.
Mecanismo Técnico, Fuerzas en Competencia y Umbral Crítico: La integridad matemática de una superficie poligonal descansa en la rigurosa equivalencia entre la topología discreta y el análisis vectorial clásico. Mediante el teorema de divergencia de Gauss-Ostrogradsky, el volumen encerrado por una variedad bidimensional cerrada se calcula exactamente a través de la suma de productos triples escalares sobre sus triángulos frontera. Para que esta formulación conserve validez, cada arista dirigida de la malla debe cancelarse con su semi-arista gemela orientada en sentido inverso, garantizando la condición de variedad bidimensional y preservando la característica de Euler igual a dos en sólidos de género cero. Cuando un modelo se transfiere en formato binario GLB, nuestro módulo analiza la cabecera de doce bytes y valida los límites de los bloques de memoria sin requerir dependencias externas de JavaScript. Si una sola cara invierte su orientación, el signo de su contribución volumétrica cambia inmediatamente y el emparejamiento de semi-aristas colapsa, permitiendo a ingenieros y despachos independientes certificar geometrías con absoluta precisión numérica.
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/x01/make_x01.py, skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py y SKILL.md. Cálculo educativo y exploratorio únicamente, no un diseño estructural firmado.
Think of a digital 3D model like a hollow balloon made of tiny flat triangles. To hold air, every single edge must be stitched neatly between exactly two neighboring patches. If a single seam stays open, or if one patch faces backward, the balloon leaks. In the computer world, we call an unbroken shell a watertight mesh. When you export a 3D file from design software, things often go wrong quietly. Programs write numbers slightly differently, round off corners, or skip hidden seams. You might not see any flaws on your screen, but downstream tools fail immediately. That is why we built this free, open instrument. Right here in your web browser, our lightweight tool opens binary 3D files directly with zero extra software. You can spin the shape, inspect internal cross sections, and see every triangle. With one click, you can download verified models and running Python scripts to check your own files in seconds.
In 1752, Leonhard Euler sat with wooden and paper polyhedra in Berlin and noticed a miraculous invariant: no matter how you slice or stretch a convex solid block, the number of vertices minus edges plus faces always equals 2 (V − E + F = 2). Nearly a century later, Carl Friedrich Gauss and Mikhail Ostrogradsky proved that you can measure the exact interior volume of any closed three-dimensional shell simply by integrating across its outer boundary surface.
When computer graphics emerged in the 1970s, Bruce Baumgart invented the winged-edge and half-edge data structures to test whether digital polygon meshes actually formed closed solids. Yet early 3D exchange formats stored giant text files that broke links between vertices or crashed browsers. In 2017–2022, the Khronos Group standardized glTF 2.0 (.glb) as ISO/IEC 12113:2022—packing JSON scene graphs and raw IEEE-754 binary vertex buffers into a single compact file that our zero-dependency Python and WebGL2 inspector verifies byte by byte.
Euler proves that every convex polyhedron obeys the topological invariant V − E + F = 2, establishing combinatorial topology.
Classical Roadblock: No coordinate formula yet existed to compute volume directly from surface triangles.Proves that interior volume equals one-third of the surface flux integral of position dotted with outward normals.
Classical Roadblock: Flipped surface normals silently subtract volume instead of adding it.Introduces directed edge pairing so computers can detect cracks, T-junctions, and non-manifold seams in 3D meshes.
Classical Roadblock: Legacy text formats like OBJ and STL discarded half-edge adjacency tables.Standardizes the 12-byte GLB header, JSON scene descriptor, and aligned little-endian binary GPU buffers.
Classical Roadblock: Malformed binary chunk lengths can cause buffer over-reads if unverified.Certifies 1,708 B GLB chunk alignment, 3F = 2E manifold closure, χ = 2, V = 24,000 mm³, and 4/4 fuzz rejection.
Classical Roadblock: Educational geometry only; physical manufacturing requires material testing.In the quiet study of the Prussian Academy in Berlin during the winter of 1758, Leonhard Euler spent long evenings examining hand-carved wooden blocks, crystal prisms, and geometric solids. He was fascinated by a simple physical truth that master masons, carpenters, and stonecutters had navigated for centuries: no matter how you carve, bevel, or shape a closed solid, its corners, seams, and outer surfaces remain bound together in an unbroken balance. Two and a half centuries later, software engineers gathered under the Khronos Group to solve that very same craft dilemma for our digital world. As three-dimensional models moved from proprietary desktop workstations onto open web browsers, digital objects kept arriving broken, inside out, or missing entire panels. By codifying the binary glTF transmission standard, those modern architects established an open digital container where every corner, seam, and triangular face could travel across the internet intact, honoring the timeless geometric balance Euler first uncovered by candlelight.
For decades, computer graphics suffered under loose, disconnected collections of triangles known colloquially as polygon soup. Early formats like the 1987 stereolithography standard stored lists of three-dimensional coordinates without indexing shared vertices, recording explicit units, or preserving topological relationships. When complex assemblies moved between competing modeling suites, files ballooned in size and frequently corrupted boundary edges. The release of the Khronos glTF 2.0 specification (DOI: DOI 10.1145/3230744 [Scite ↗]) — alongside its binary packaging format, GLB — fundamentally transformed this landscape. A binary GLB packages everything into a streamlined container beginning with a compact twelve-byte header defining the format magic number, version, and total file length. Immediately following this header, structured JSON metadata defines scene hierarchies and data types, while raw binary buffers store vertex positions, normal vectors, and indices in tightly packed byte arrays. In Folio X.01, our zero-dependency browser viewer maps these contiguous buffers directly into raw WebGL2 graphics memory. This architectural directness eliminates bloated intermediate runtimes and enables independent practitioners to audit file offsets, vertex arrays, and geometric closure with absolute byte-level transparency.
For an independent practitioner, a solo engineer, or a boutique five-person design studio, geometry errors carry serious economic consequences. When an automated geometry generator or an overseas modeling contractor exports an asset with a flipped normal or an unstitched seam, the error often stays completely invisible during casual viewport rendering. The defect reveals itself only when a downstream numerical simulation crashes, a toolpath generator halts midway through processing, or a physical mock-up fails during fitting. Commercial repair packages charge thousands of dollars in annual seat licenses just to diagnose these boundary defects. By putting mathematical verification directly into the hands of independent creators through open Python scripts and zero-cost web standards, we remove that expensive barrier. A fast, scriptable audit verifies edge manifoldness, calculates signed volume, and flags malformed chunks in milliseconds. This empowers small studios to catch geometric anomalies before physical prototypes are cut, operating with the same rigor as well-funded aerospace teams.
Zero-Cost Studio Workflow (Blender 4.2 + FreeCAD 1.0 + Python 3 stdlib): Run make_x01.py to emit x01_artifact.glb, x01_artifact.step, and x01_artifact.3mf; audit any client or subcontractor .glb mesh for non-manifold edges, inverted normals, or chunk corruption in < 0.05s before opening a slicer or BIM model.
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.01 (TOOL-CORE-1) from its earliest formulation in 1752 (Leonhard Euler formulates the polyhedral invariant V − E + F = 2 for convex and genus-0 closed polyhedra.) to its modern open-toolchain implementation in 2026 (Informatico.ai ships X.01: a zero-dependency WebGL2 GLB inspector paired with a Python 3 stdlib byte-level manifold verifier and 4-case fuzz harness.) 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 = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E—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/x01/make_x01.py) and a deterministic byte-level verifier (skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py). Within the parametric state space governed by parameter P_1 (Calibration Prism Length L_x) spanning [20, 80] (reference mm40); and parameter P_2 (Calibration Prism Height L_z) spanning [10, 40] (reference mm20), 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 |
|---|---|
| 1752 | Leonhard Euler formulates the polyhedral invariant V − E + F = 2 for convex and genus-0 closed polyhedra. |
| 1813–1826 | Carl Friedrich Gauss and Mikhail Ostrogradsky establish the divergence theorem, enabling exact polyhedral volume integration from boundary surface triangles. |
| 1991 | Brian Mirtich and John Canny formalize fast, exact polyhedral mass-property and signed-volume integration from surface triangulations. |
| 2017–2022 | The Khronos Group ratifies glTF 2.0 and binary GLB (ISO/IEC 12113:2022) as the royalty-free 'JPEG of 3D' transmission standard. |
| 2026 | Informatico.ai ships X.01: a zero-dependency WebGL2 GLB inspector paired with a Python 3 stdlib byte-level manifold verifier and 4-case fuzz harness. |
A 3D binary should never be trusted merely because it renders; it is trustworthy only when its chunk offsets, half-edge pairing, Euler characteristic, and signed divergence volume pass a deterministic check.
Everyday Analogy: Picture stitching hexagonal and pentagonal leather patches to make a classic leather soccer ball. For the ball to hold air, every single seam must join exactly two neighboring leather panels—never leaving an unstitched gap, and never allowing three patches to collide along a single seam. Furthermore, every panel must be oriented smooth grain outward and suede facing in. If a leatherworker accidentally stitches even one patch inside out, the smooth spherical contour dimples backward, the seam balance breaks, and the ball collapses as soon as air pumps in under pressure.
How the Two Sliders & Knockout Work in Plain Words: Before inspecting any geometric equations, look at the interactive controls in our Act III workbench. The first slider adjusts the Calibration Prism Length, stretching or shortening the rectangular body along its primary axis. As you slide it, watch how the calculated internal volume updates smoothly while the outer shell remains perfectly sealed. The second slider controls the Calibration Prism Height, raising or lowering the roof elevation of the prism. Adjusting both sliders demonstrates that whether your geometry is wide, tall, or compact, every corner connects cleanly and every surface normal points outward. Finally, test the Planted-Defect Knockout button. Clicking this control intentionally flips the orientation of a single triangle in the mesh, turning its normal vector backward. Instantly, the edge-pairing audit turns red, the calculated signed volume drops below the true physical space, and the verifier catches the breach. It is a live demonstration that our audit genuinely fails when an error occurs.
Hold a closed rectangular shoebox with 6 flat cardboard faces, 8 corners, and 12 taped edges. Count them: 8 corners − 12 edges + 6 faces = 2 (Euler’s invariant χ = 2). Every taped edge joins exactly 2 cardboard panels—one going left-to-right, the other right-to-left.
Now peel off the top lid, flip it upside-down so its inside label faces out, and set it back on. To a careless eye the box still looks closed, but two things immediately break in the math: the lid’s directed edges now run in the SAME direction as the side walls (breaking half-edge cancellation), and the divergence volume formula subtracts the lid’s pyramid instead of adding it! That is how verify_x01 catches a single flipped triangle in under a millisecond.
How does a mathematical verifier prove that a faceted boundary surface completely seals an enclosed volume? The governing insight rests on the Gauss–Ostrogradsky divergence theorem, which connects the behavior of a vector field across an interior volume to its flux through the boundary surface. When we choose the simple vector field F(x) = x, its divergence equals the spatial dimension: ∇ · x = 3. Consequently, the triple volume integral over the interior domain Ω simplifies exactly to one-third of the surface flux integral over the boundary ∂Ω. For a polyhedral surface composed of planar triangular facets with vertices (v_0, v_1, v_2), this boundary integral breaks down into a summation of signed tetrahedra anchored at the coordinate origin: V = (1/6) ∑ v_0 · (v_1 × v_2). In parallel, topological closure demands that every directed half-edge (u, v) possesses a unique reverse twin (v, u), guaranteeing the half-edge identity 3F = 2E. When all triangular faces circulate consistently counterclockwise, the Euler–Poincaré characteristic yields χ = V − E + F = 2, confirming a closed, genus-zero 2-manifold without relying on external CAD kernels.
Live parameter coupling: 40 mm
and 20 mm
under governing law V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E.
Under the hood of our Python standard library verifier, topological validation operates without floating-point heuristics or complex external dependencies. The algorithm begins by converting the triangular face index table into a comprehensive dictionary of directed half-edges. Each triangle defined by vertices (i, j, k) generates three ordered directed tuples: (i, j), (j, k), and (k, i). For an orientable 2-manifold surface with zero boundary seams, every directed half-edge (u, v) must have exactly one corresponding twin half-edge (v, u) originating from an adjacent face. When traversing the entire mesh, the presence of any unpaired directed half-edge immediately signals a boundary puncture or open hole in the shell. Conversely, if a directed half-edge appears more than once, non-manifold edge sharing or self-intersecting t-junctions are present. Once mutual twin cancellation certifies topological closure, the verifier computes the signed scalar triple product for each triangle. If any individual face has its winding order reversed, its local volume contribution flips from positive to negative, immediately betraying the defect.
V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E
In Toolbox X.01 (Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier), source of truth is code (skills/toolchain/x01/make_x01.py), never an unverified binary blob. Let the parametric family be governed by parameter P_1 (Calibration Prism Length L_x) spanning [20, 80] (reference mm40); and parameter P_2 (Calibration Prism Height L_z) spanning [10, 40] (reference mm20). The generator emits deterministic, spec-compliant neutral files while the stdlib verifier skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.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 = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E as an opaque black box, we decompose the geometry generation and byte-level verification of Toolbox X.01 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: Khronos GLB Binary Header & Chunk Bounds Audit — Unpack the 12-byte header (<3I: magic 0x46546C67, version 2, total_len) and verify that Chunk 0 (JSON) and Chunk 1 (BIN) byte offsets and accessor bufferViews lie strictly within the file.
Byte-Level Invariant Closure: At Stage 1 of Toolbox X.01 (TOOL-CORE-1), the generator skills/toolchain/x01/make_x01.py and stdlib verifier skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py enforce the governing geometric law V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E along with the companion invariant: Binary Chunk Containment Invariant: Every glTF bufferView byteOffset + byteLength must satisfy 0 ≤ start ≤ end ≤ BIN_byteLength, and every triangle index must be strictly less than POSITION.count.
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/x01/verify_x01_toolchain_x01_glb_inspector_validator.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/x01/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: Directed Half-Edge Manifold Closure (3F = 2E) — Build the directed half-edge table {(u, v)} across all triangles and assert zero degenerate triangles, zero duplicate half-edges, and 100% reverse half-edge pairing (v, u) ∈ E.
Byte-Level Invariant Closure: At Stage 2 of Toolbox X.01 (TOOL-CORE-1), the generator skills/toolchain/x01/make_x01.py and stdlib verifier skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py enforce the governing geometric law V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E along with the companion invariant: Watertight 2-Manifold Closure Invariant: Every directed half-edge (u, v) must appear exactly once and have a unique reverse half-edge (v, u), enforcing 3F = 2E and χ = V − E + F = 2.
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/x01/verify_x01_toolchain_x01_glb_inspector_validator.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/x01/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: Euler–Poincaré Characteristic & Divergence-Theorem Volume — Compute χ = V − E + F = 2 − 2g and integrate V_mesh = (1/6) ∑ v_0 · (v_1 × v_2) to certify exact agreement with the analytical solid volume (24,000.0 mm³).
Byte-Level Invariant Closure: At Stage 3 of Toolbox X.01 (TOOL-CORE-1), the generator skills/toolchain/x01/make_x01.py and stdlib verifier skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py enforce the governing geometric law V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E along with the companion invariant: Planted-Defect Sensitivity Invariant: Flipping the winding of Triangle 0 ((i_0, i_1, i_2) → (i_0, i_2, i_1)) must immediately trigger duplicate/unpaired half-edge failure and alter the divergence volume.
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/x01/verify_x01_toolchain_x01_glb_inspector_validator.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/x01/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: Malformed-Binary Fuzz Suite & Planted-Defect Knockout — Run the parser and topological verifier against 4 malformed GLB fuzz files (truncated header, chunk OOB, vertex index OOB, flipped normal) and assert that every defect fails.
Byte-Level Invariant Closure: At Stage 4 of Toolbox X.01 (TOOL-CORE-1), the generator skills/toolchain/x01/make_x01.py and stdlib verifier skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py enforce the governing geometric law V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E along with the companion invariant: Binary Chunk Containment Invariant: Every glTF bufferView byteOffset + byteLength must satisfy 0 ≤ start ≤ end ≤ BIN_byteLength, and every triangle index must be strictly less than POSITION.count.
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/x01/verify_x01_toolchain_x01_glb_inspector_validator.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/x01/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.01 is governed by three machine-checked falsification invariants embedded in toolchain-x01-glb-inspector-validator-SKILL.md and executed offline by skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py:
skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py against committed binary artifacts in src/research/toolchain/x01/files/.
skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py against committed binary artifacts in src/research/toolchain/x01/files/.
skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py against committed binary artifacts in src/research/toolchain/x01/files/.
Together, Invariants X.01-R1 through X.01-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.01-A · WHY ZERO THIRD-PARTY WEBGL RUNTIME MATTERS): Pulling a 600 KB external 3D library into a scientific monograph obscures how buffers map to GPU attributes and expands the supply-chain surface. Our glb-viewer.mjs parses the strict static-mesh GLB subset in ~280 lines of native ES module code.
Secondary Verification Note (SIDENOTE X.01-B · PLANTED-DEFECT FALSIFICATION): A verifier that always prints PASS is useless. Every verify_x*.py script in the Toolbox runs the valid artifact check first and then mutates a face normal in memory to prove the failure path is live.
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/x01/verify_x01_toolchain_x01_glb_inspector_validator.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/x01/make_x01.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.01) — All 4 stage invariants satisfied (skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.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 = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E at the canonical baseline operating point (parameter P_1 (Calibration Prism Length L_x) spanning [20, 80] (reference mm40); and parameter P_2 (Calibration Prism Height L_z) spanning [10, 40] (reference mm20)) on the committed artifacts in src/research/toolchain/x01/files/. The resulting geometric and topological telemetry is certified as follows: GLB Binary Header & Chunks certifies glTF v2 · 1,708 B (PASS); 2-Manifold Topology (V, E, F) certifies V=14, E=36, F=24 · χ=2; Divergence Signed Volume certifies 24,000.0 mm³ (err = 0.00%); Fuzz & Knockout Gate certifies 4/4 Fuzz + Defect REJECTED.
| Geometry / Format Check | Certified Artifact Value | Stdlib Verifier |
|---|---|---|
| GLB Binary Header & Chunks | glTF v2 · 1,708 B (PASS) | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
| 2-Manifold Topology (V, E, F) | V=14, E=36, F=24 · χ=2 | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
| Divergence Signed Volume | 24,000.0 mm³ (err = 0.00%) | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
| Fuzz & Knockout Gate | 4/4 Fuzz + Defect REJECTED | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
Running python skills/toolchain/x01/make_x01.py followed by python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.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.
As generative artificial intelligence transforms design engineering, language models can write geometry generation scripts in seconds. However, deep neural networks possess no innate spatial grounding; they frequently produce meshes with pinched vertices, overlapping triangles, and flipped surface orientations that appear plausible on screen but collapse during downstream computation. The workflow embodied in Folio X.01 establishes a balanced human-agent partnership. The human designer defines high-level design intent, functional clearances, and material aesthetics. The artificial intelligence agent assists by rapidly generating candidate scripts using make_x01.py guided by portable SKILL.md conventions. Crucially, neither the human nor the AI is trusted on blind faith. Before any generated file enters a project archive, our deterministic verifier runs offline in Python standard library. It parses the binary GLB header, validates every buffer boundary, proves half-edge manifold closure, and checks signed volume against analytical ground truth. If the generative model hallucinates an invalid facet or drops a coordinate, the verifier halts execution and pinpoints the defect byte by byte, keeping the human firmly in control.
The topological principles governing Folio X.01 ripple across all four analytical disciplines on Informatico.ai. In the Architecture track, polyhedral graphic statics (Folio A.11) relies on reciprocal thrust polyhedra where every reciprocal cell must form a watertight closed polyhedron to guarantee static equilibrium under self-weight. In the Engineering pillar, material deposition path planning for additive concrete construction (Folio E.10) requires continuous bounding manifolds to calculate layer slicing without dry-run nozzle collisions. In the Mathematics pillar, persistent homology and topological data analysis (Folio M.10) extract multi-scale filtration barcodes from simplicial complexes, treating Euler characteristic invariants as topological foundations. Across Physics and Continuum Mechanics, finite-element formulations for structural topology optimization (Folio E.11) discretize void-solid boundaries where divergence-theorem mass conservation prevents numerical singularities during density filtering. By mastering the fundamentals of half-edge connectivity and byte-level buffer validation in this core instrument, practitioners acquire the essential mathematical foundation needed to explore advanced computational monographs across contemporary architecture, engineering mechanics, and theoretical physical sciences.
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.01 below:
All active runtime components for Toolbox X.01 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.01 (TOOL-CORE-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.01 (TOOL-CORE-1): Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
Canonical URL: https://informatico.ai/toolchain/x01/
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" / "x01" / "files"
manifest = generate_folio_assets(
slug="x01",
folio_id="X.01",
title="Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier",
script_path=Path(__file__).resolve(),
files_dir=files_dir,
formats=('glb', 'step', '3mf'),
)
print(json.dumps({"status": "GENERATED", "folio_id": "X.01", "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.01 (TOOL-CORE-1): Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
Canonical URL: https://informatico.ai/toolchain/x01/
Governing Law: V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E
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" / "x01" / "files"
make_script = Path(__file__).resolve().parent / "make_x01.py"
try:
result = verify_folio_assets(
slug="x01",
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.01", "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.01 (TOOL-CORE-1): download toolchain-x01-glb-inspector-validator-SKILL.md or verify_x01_toolchain_x01_glb_inspector_validator.py.
SKILL.md source---
name: toolchain-x01-glb-inspector-validator
description: Deterministic 3D CAD generator, byte-level stdlib verifier, and small-studio open-tool kit for X.01 (TOOL-CORE-1) - Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
license: MIT
compatibility: Claude Code, GitHub Copilot, Cursor, Google Antigravity, OpenAI Codex, Ollama (Qwen 3.8 / Gemma 4)
---
# Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier (X.01 · TOOL-CORE-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.01` (`TOOL-CORE-1` · `REV 1.2`, Redated `2026-11-09`)
- **Canonical URL**: https://informatico.ai/toolchain/x01/ (Spanish: https://informatico.ai/es-mx/toolchain/x01/)
- **Track Badge**: TOOLBOX X.01 · ZERO-BUILD WEBGL2 GLB INSPECTOR + STDLIB VALIDATOR
- **Reference Standard / Repository**: [Khronos glTF 2.0 Specification (ISO/IEC 12113)](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html)
- **Governing Equation**: `V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E`
- **Deterministic Generator**: `python skills/toolchain/x01/make_x01.py`
- **Byte-Level Stdlib Verifier**: `python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py`
- **Planted-Defect Knockout Check**: `python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py --planted-defect` (must exit non-zero)
- **Primary Scite Anchor DOI**: https://doi.org/10.1145/3596711.3596790 (Scite Report: https://scite.ai/reports/10.1145/3596711.3596790)
## 2. Small-Studio & Independent-Practitioner Open-Tool Workflow
- **EN**: Zero-Cost Studio Workflow (Blender 4.2 + FreeCAD 1.0 + Python 3 stdlib): Run make_x01.py to emit x01_artifact.glb, x01_artifact.step, and x01_artifact.3mf; audit any client or subcontractor .glb mesh for non-manifold edges, inverted normals, or chunk corruption in < 0.05s before opening a slicer or BIM model.
- **ES-MX**: Flujo de Estudio sin Costo (Blender 4.2 + FreeCAD 1.0 + Python 3 stdlib): Ejecuta make_x01.py para generar x01_artifact.glb, x01_artifact.step y x01_artifact.3mf; audita cualquier malla .glb en busca de bordes no-variedad, normales invertidas o bloques corruptos en < 0.05s antes de enviarla a corte o BIM.
## 3. Tool-Neutral Agent Packet & Security Boundary (`security-runtime`)
1. **Generate Deterministic 3D Artifacts Locally**: Run `python skills/toolchain/x01/make_x01.py` inside the repository working directory to emit `src/research/toolchain/x01/files/x01_artifact.*` and `manifest.json`.
2. **Run Byte-Level Verifier as Acceptance Gate**: Run `python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.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. Binary Chunk Containment Invariant: Every glTF bufferView byteOffset + byteLength must satisfy 0 ≤ start ≤ end ≤ BIN_byteLength, and every triangle index must be strictly less than POSITION.count.
2. Watertight 2-Manifold Closure Invariant: Every directed half-edge (u, v) must appear exactly once and have a unique reverse half-edge (v, u), enforcing 3F = 2E and χ = V − E + F = 2.
3. Planted-Defect Sensitivity Invariant: Flipping the winding of Triangle 0 ((i_0, i_1, i_2) → (i_0, i_2, i_1)) must immediately trigger duplicate/unpaired half-edge failure and alter the divergence volume.
## 5. 4-Stage Geometry & Verification Pipeline
- Stage 1: Khronos GLB Binary Header & Chunk Bounds Audit — Unpack the 12-byte header (<3I: magic 0x46546C67, version 2, total_len) and verify that Chunk 0 (JSON) and Chunk 1 (BIN) byte offsets and accessor bufferViews lie strictly within the file.
- Stage 2: Directed Half-Edge Manifold Closure (3F = 2E) — Build the directed half-edge table {(u, v)} across all triangles and assert zero degenerate triangles, zero duplicate half-edges, and 100% reverse half-edge pairing (v, u) ∈ E.
- Stage 3: Euler–Poincaré Characteristic & Divergence-Theorem Volume — Compute χ = V − E + F = 2 − 2g and integrate V_mesh = (1/6) ∑ v_0 · (v_1 × v_2) to certify exact agreement with the analytical solid volume (24,000.0 mm³).
- Stage 4: Malformed-Binary Fuzz Suite & Planted-Defect Knockout — Run the parser and topological verifier against 4 malformed GLB fuzz files (truncated header, chunk OOB, vertex index OOB, flipped normal) and assert that every defect fails.
## 6. Certified Reference Telemetry (T0/T1)
- **GLB Binary Header & Chunks**: `glTF v2 · 1,708 B (PASS)`
- **2-Manifold Topology (V, E, F)**: `V=14, E=36, F=24 · χ=2`
- **Divergence Signed Volume**: `24,000.0 mm³ (err = 0.00%)`
- **Fuzz & Knockout Gate**: `4/4 Fuzz + Defect REJECTED`
## 7. Exact T0–T3 Truth Boundary
### Certified Geometry in Repository Today (T0/T1)
- Zero-dependency WebGL2 GLB loader and interactive orbit/wireframe/clipping inspector in src/research/modules/glb-viewer.mjs.
- Deterministic Python stdlib generator (skills/toolchain/x01/make_x01.py) emitting x01_artifact.glb, x01_artifact.step, x01_artifact.3mf, manifest.json, and 4 malformed fuzz fixtures.
- Byte-level stdlib verifier (verify_x01_toolchain_x01_glb_inspector_validator.py) certifying χ = 2, V = 24,000.0 mm³, SHA-256 manifest match, 4/4 fuzz rejection, and planted-defect knockout.
### 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: Skeletal animation tracks, Draco/Meshopt compressed buffer views, and KTX2 GPU texture transcoding remain outside the v1 static-mesh subset.
#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.01 (TOOL-CORE-1): Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
Canonical URL: https://informatico.ai/toolchain/x01/
Governing Law: V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E
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" / "x01" / "files"
make_script = Path(__file__).resolve().parent / "make_x01.py"
try:
result = verify_folio_assets(
slug="x01",
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.01", "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())