Shape Factory: Structured 3D Generation

• Shape Factory is a framework that defines methods to generate, transform, and annotate 3D objects using reusable intermediate representations and structured production pipelines.
• It employs diverse methodologies such as graph-based procedural modeling, primitive assembly generation, and latent space factorization to achieve semantic, function-aware correspondences.
• Applications range from robotics manipulation and CAD analysis to fabrication and programmable matter reconfiguration, enabling efficient, scalable, and constraint-aware shape production.

Searching arXiv for relevant papers on “Shape Factory” and adjacent 3D shape-generation/fabrication systems. “Shape Factory” (Editor’s term) denotes a family of systems in which 3D shapes are produced, transformed, annotated, or reconfigured through reusable representations rather than treated as isolated meshes. In the recent literature, this role is instantiated by plug-and-play Shape Libraries for category-level manipulation, Standard Concept Template Library (STL-C) for object conceptualization, human-created primitive assemblies, recursive text-conditioned latent distributions, Graph-based Procedural Shape (GPS) programs, fabrication-aware reforming, and programmable-matter reconfiguration. The term is used explicitly in the ShapeGen description as a “Shape Factory” for robotics, and the broader pattern suggests a common research program centered on structured variation, function-aware correspondence, and downstream usability rather than one-shot synthesis alone (Wang et al., 16 Apr 2026, Sun et al., 2024, Ye et al., 7 May 2025, Fu et al., 2022, Zhang et al., 20 Oct 2025).

1. Structural premise and conceptual scope

A recurring premise across this literature is that shape should be represented through explicit structure. ConceptFactory traces this to human cognition research, stating that the perceptual recognition of objects can be explained as a process of arranging generalized geometric components such as cuboids and cylinders, and it operationalizes this view through object conceptualization for both vision and robotics (Sun et al., 2024). PrimitiveAnything makes a closely related claim from the generative side: shape primitive abstraction “plays a crucial role in human visual cognition,” and the system therefore reformulates shape primitive abstraction as a primitive assembly generation task rather than a pure fitting problem (Ye et al., 7 May 2025).

This structural emphasis also appears in latent and recursive models. “Composite Shape Modeling via Latent Space Factorization” models the embedding space as a direct sum of part subspaces,

$V = V_1 \oplus V_2 \oplus \ldots \oplus V_K,$

so that shape composition and decomposition become linear operations on embedding coordinates, with learned projection matrices enforcing idempotence, orthogonality, and partition of identity (Dubrovina et al., 2019). ShapeCrafter opposes the assumption that text-conditioned 3D generation must be one-shot: existing methods “consume an entire text prompt to generate a 3D shape in a single step,” whereas ShapeCrafter models a recursive process in which an initial description is progressively refined and the shape distribution evolves as more phrases are added (Fu et al., 2022).

A common misconception is that a shape factory is synonymous with generic text-to-mesh output. The surveyed systems collectively reject that reduction. Some prioritize semantic decomposition, some prioritize functionally corresponding points, some prioritize fabrication or packing, and some prioritize local reconfiguration under extreme computational constraints. This suggests that “factory” is best understood as a pipeline property: the ability to repeatedly generate valid variants, annotations, or reconfigurations from a reusable intermediate representation.

2. Reusable representations, libraries, and intermediate forms

Several systems define reusable intermediate forms that make shape production compositional and scalable.

System	Core representation	Stated function
ShapeGen	plug-and-play Shape Library	functionally corresponding point mappings
ConceptFactory	Standard Concept Template Library (STL-C)	object conceptualization and annotation
PrimitiveAnything	human-created primitive assemblies	primitive assembly generation
ShapeCraft	Graph-based Procedural Shape (GPS)	structured, textured and interactive 3D modeling
Shape	structured 3D latent grid with MAGNO	dense per-token embeddings for CAD analysis

In ShapeGen, the library is built from “spatial warpings between shapes mapping points to points that correspond functionally,” and new shapes can be integrated in constant time by composing warpings through a fixed template shape. A refinement step projects warped correspondences onto the true surface for accuracy:

$$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$

This representation is explicitly described as plug-and-play and is the basis for large-scale substitution of object geometry in demonstrations (Wang et al., 16 Apr 2026).

ConceptFactory provides a different form of reuse. STL-C contains reusable geometry templates and concept templates implemented as Python classes; the released library includes 263 distinct concept templates, and the associated asset contains 4,380 objects from 39 categories, with 39,000 geometry instance applications and 295,000 parameters (Sun et al., 2024). Once a concept is fitted, region-based knowledge and pose-based knowledge can be defined procedurally at the template level and propagated programmatically to object instances.

PrimitiveAnything encodes each primitive as a tuple of type, scale, rotation, and translation, and introduces an ambiguity-free parameterization to eliminate symmetry-induced multiple descriptions of the same primitive. The training corpus, HumanPrim, contains 120,000 3D models with human-created primitive assemblies, averaging approximately 31 primitives per object and up to 144; supported primitives include cuboids, elliptical cylinders, and ellipsoids (Ye et al., 7 May 2025). ShapeCraft adopts a programmatic representation instead of a tokenized primitive set. Its GPS representation is a directed, rooted graph

$$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$

where each node carries geometric description, positional description, bounding volume, and a code snippet for procedural modeling (Zhang et al., 20 Oct 2025).

The CAD-oriented “Shape” model introduces yet another intermediate form: a fixed-size 3D latent grid processed by a multi-scale geometry-aware tokenizer (MAGNO). The released model uses a $24 \times 24 \times 24$ grid, aggregates 28-dimensional geometry statistics at radii $\{0.05, 0.1, 0.2\}$, and converts arbitrary-resolution surface meshes into dense per-token embeddings (Mounmo et al., 19 Apr 2026). Taken together, these systems indicate that the principal engineering decision in a shape factory is often not the decoder but the choice of reusable representation.

3. Generative pipelines from language, images, and sketches

Recent generative systems differ chiefly in how they stage the production process. CRAFT addresses body-aware design: it synthesizes body-aware 3D objects from a base mesh given an input body geometry and either text or image as guidance, and it optimizes a mesh deformation procedure for semantic alignment as well as contact and penetration losses. The generated objects can be simulated on virtual characters or fabricated for real-world use, and the interface accepts text, image, or sketch without manual artist intervention (Guo et al., 2024).

ShapeCrafter models generation as a recursive update of a latent distribution rather than a single pass. It uses a P-VQ-VAE with an $8 \times 8 \times 8$ grid of latent indices, codebook size $K = 512$, feature size $D = 256$, and BERT text embeddings projected into grid space. The dataset Text2Shape++ contains 369,000 shape-text pairs and was created to support recursive shape generation, local detail refinement, editing, and extrapolation (Fu et al., 2022). PrimitiveAnything adopts an auto-regressive decoder-only transformer conditioned on the input point cloud and previous primitives:

$p_i = F(\mathcal{C}; p_1, ..., p_{i-1}).$

Its loss is

$$\mathcal{L} = \mathcal{L}_{eos} + \mathcal{L}_{ce} + \mathcal{L}_{cd},$$

and the reported quantitative results show $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$0 against $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$1 for EMS and $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$2 for Marching-Primitives, with $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$3 against $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$4 for Marching-Primitives (Ye et al., 7 May 2025).

ShapeCraft moves further toward agentic program synthesis. It represents 3D assets as shape programs and organizes generation through Parser, Coder, and Evaluator agents over GPS. For each node, the Coder employs multi-path sampling with $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$5 candidate paths and iterative refinement for $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$6 steps, while the Evaluator provides visual and code-based feedback. On 26 functional, long-form prompts from MARVEL-40M+, ShapeCraft reports $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$7, Hausdorff Distance $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$8, CLIP $$\mathrm{refine}(\mathbf{x}, S) = \arg\min_{\mathbf{y} \in S}\|\mathbf{x} - \mathbf{y}\|_2.$$9, VQA Pass Rate $$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$0, runtime $$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$1 minutes, and 21 API calls (Zhang et al., 20 Oct 2025).

These systems clarify a second misconception: high-quality shape factories are not necessarily one-shot or purely geometric. Some are recursive, some are programmatic, and some are explicitly embodiment-aware. This suggests that prompt alignment, editability, compilability, and fabricability are now first-class objectives alongside geometric fidelity.

4. Function-aware generation for robotics and object knowledge

In robotics, the shape-factory idea is unusually concrete. ShapeGen is explicitly described as a “Shape Factory” for Robotics. Its core objective is category-level manipulation under in-category geometric diversity, and it is designed to generate shape-variated manipulation data in a simulator-free and 3D manner (Wang et al., 16 Apr 2026).

The method decomposes into “Shape Library curation” and “Function-Aware Generation.” During curation, ShapeGen learns dense spatial warpings $$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$2 supervised by Signed Distance Functions, with loss

$$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$3

During generation, the user provides minimal annotation by clicking a small set of functionally relevant keypoints; this is described as a “1-minute task.” Function-aware alignment minimizes a user-specified keypoint cost, gripper action correction updates the robot trajectory, and new observations are generated by compositing the substituted object into the captured scene. The paper reports that data for novel shapes can be generated 15 times faster than manual teleop recording, and that policies trained on ShapeGen-augmented datasets generalize robustly to new, previously unseen shapes in the same object category (Wang et al., 16 Apr 2026).

ConceptFactory addresses a related problem from the annotation side rather than the demonstration side. After conceptualization, it supports procedural definition of region-based knowledge, such as semantic segmentation and affordance regions, and pose-based knowledge, such as part poses and grasp poses. The platform uses automatic gradient-based optimization and reports 7 min/object with optimizer. In robotic manipulation benchmarks, models trained with ConceptFactory’s human-assigned affordances outperformed simulation-generated annotation by $$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$4 to $$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$5 success rate, depending on task (Sun et al., 2024).

A plausible implication is that robotics-oriented shape factories are increasingly dual-purpose. They are not merely generators of geometry; they are generators of correspondences, affordances, and corrected action traces. In that sense, the output is a training corpus as much as an object.

5. Fabrication, packing, and material-specific reshaping

A distinct branch of shape-factory research is concerned with physical realization. Mesh2Fab is a data-driven reforming algorithm that adapts an input multi-component model for a target fabrication material, specifically wood or metal. It reforms both part geometry and inter-part topology, infers likely joint types from material and geometric relations, and outputs the reshaped model with part dimensions and inter-part junction specifications (Yang et al., 2014). The database contains 152 component-based 3D models, and the user study evaluated 35 reform results with 30 users, yielding an average correct identification rate of 91.5% when participants judged the likely fabrication material from geometry alone (Yang et al., 2014).

“Shapes In A Box” addresses another downstream constraint: efficient packing and fabrication. Its split-and-pack pipeline first creates a hierarchy of possible parts that can be tightly packed within their minimum bounding boxes and then extracts the segmentation whose parts can be most tightly packed. The segmentation cost is the “absolute aboxiness”

$$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$6

and packing efficiency is

$$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$7

For complex organic shapes, the reported packing efficiency increases from 5–12% up to 40–48%; against alternate segmentation strategies, the box-based hierarchical segmentation yields 19–23% higher packing efficiency, while box-like parts reach approximately 88–91% efficiency (Attene, 2021).

FluxLab extends the factory notion to shape-changing devices with integrated deformation sensing. Its printable nesting structure combines a central SMA channel, lattice-based padding, and parallel helix-based surface wires, and it provides FluxEditor for geometric embedding and FluxShaper for deformation authoring with an LSTM-based RNN classifier. Reported F1 scores range from 88.7% for lower lattice solidity to 77.8% for higher rigidity (Lee et al., 2 Dec 2025). Here the product of the factory is not a static artifact but a 3D-printable mechanism whose deformation can be sensed and classified.

This branch of the literature makes clear that shape generation is often subordinate to manufacturing constraints. Material, joinery, minimum bounding boxes, printer behavior, and actuation all feed back into what counts as a valid or useful shape.

6. Reconfiguration, complexity bounds, and foundation-model regimes

At the opposite end of the spectrum from rich neural generation are programmable-matter results that treat shape as a distributed reconfiguration problem. “Shape Formation by Programmable Particles” studies anonymous particles with constant memory, local interaction, and adversarial scheduling in the geometric Amoebot model. The paper proves that chirality is computationally irrelevant for shape formation, characterizes deterministic feasibility in the presence of unbreakable $$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$8-symmetry, and gives a universal algorithm with $$\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{A}),$$9 rounds and moves; the move bound is asymptotically optimal (Luna et al., 2017). Randomization removes the symmetry barrier when $24 \times 24 \times 24$0 is large enough.

“Efficient Shape Reconfiguration by Hybrid Programmable Matter” studies a single active agent with finite-automaton power that lifts and places passive tiles on the triangular lattice. The target nodes are distinguishable, overlap between input and target is exploited explicitly, and the resulting algorithms achieve worst-case optimal $24 \times 24 \times 24$1 time for simply connected target shapes and $24 \times 24 \times 24$2 time for a large class of bottleneck-free target shapes with holes (Friemel et al., 15 Jan 2025). These results show that in some settings a shape factory is best formalized not as a generator but as a reconfiguration algorithm with strict locality and connectivity constraints.

The CAD foundation-model literature introduces a different kind of limit: not symmetry or connectivity, but statistical calibration. “Shape: A Self-Supervised 3D Geometry Foundation Model for Industrial CAD Analysis” pretrains a 10.9M-parameter backbone on 61,052 CAD meshes and evaluates on a held-out split of 2,983 meshes, achieving reconstruction $24 \times 24 \times 24$3 and 98.1% top-1 retrieval under the Wang-Isola protocol (Mounmo et al., 19 Apr 2026). Its central ablation result is unusually sharp: per-dimension normalization is critical, and without it performance collapses to $24 \times 24 \times 24$4 and top-1 $24 \times 24 \times 24$5; with it, both MSE and Smooth-L1 succeed with $24 \times 24 \times 24$6 and top-1 $24 \times 24 \times 24$7 (Mounmo et al., 19 Apr 2026). The model’s learned reconstruction prior also provides per-region attribution maps, so explainability is built into the training objective rather than added post hoc.

Taken together, these results delimit the shape-factory idea. The output may be a family of manipulable objects, a corpus of annotated instances, a fabricated assembly, a packed kit, a self-changing device, or a reconfigured lattice occupancy. But every regime imposes its own bottlenecks: symmetry barriers in programmable matter, manufacturability in physical fabrication, and normalization-sensitive objectives in self-supervised geometry learning. The literature therefore supports a precise interpretation of shape factories as systems for structured shape throughput under explicit constraints, not merely systems for producing more geometry.