Papers for

mechanical design engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Mechbench measures large language models ability on parallel mechanisms

MechBench: A Domain-Specific LLM Benchmark for Parallel Mechanisms

Abstract: Parallel mechanisms pose distinctive challenges to large language models (LLMs), as valid reasoning depends jointly on mechanism topology, loop closure, geometry, joint types, and modeling assumptions. Yet existing LLM benchmarks provide little systematic coverage of such domain-specific knowledge, constraint-sensitive analysis, and constructive design. To fill this gap, we introduce MECHBENCH, a 2,541-question benchmark for evaluating LLMs in parallel mechanisms across professional knowledge, mechanism analysis, and design. MECHBENCH contains standard and challenge tiers spanning six capability categories and nine executable analysis and design tasks. It is constructed through MECHFORGE, a domain-grounded framework that combines expert-organized knowledge, LLM-assisted question generation, programmatic instance generation, two-stage expert review, and task-aware scoring with exact matching, rubric-based evaluation, and program verification. We further develop MECHGPT as a diagnostic domain-adapted model. Experiments show that strong knowledge performance does not directly translate into executable mechanism reasoning: leading closed-service models achieve over 95 on the standard tier but only 47-60 on the challenge tier, while domain adaptation substantially improves MechGPT over its Qwen3-8B baselines but leaves a large gap in constrained analysis and design. These results establish MECHBENCH as a systematic testbed for measuring domain-specific LLM capabilities in mechanism science.

Wed 11 NovMachine Learning
The gist
Large language models (LLMs) struggle to handle questions about parallel mechanisms, which require understanding complex details like their shapes, joints, and how they move. The authors created MechBench, a big set of questions designed to test LLMs on this special knowledge and task-solving for those machines. They also made MechGPT, a version of an LLM fine-tuned for these tasks. Their tests show that even the best current models find hard questions challenging, confirming MechBench as a useful tool to measure LLM skills in this area.
Open → 2611.15342v1

Reinforcement learning guides multi-objective design optimizations effectively

MOON-RL: Multi-Objective Optimization via Objective Space Navigation with Reinforcement Learning

Abstract: Many engineering design problems involve multiple conflicting objectives and strict feasibility constraints. They are typically solved with population-based optimizers that require many evaluations and offer limited online control over where the search is focused. We present MOON-RL, a reinforcement-learning-based optimization framework that formulates constrained multi-objective search as preference-directed navigation in the objective space. In MOON-RL, a lightweight PPO policy receives objective-space and constraint-related observations and acts as an instance-specific adaptive search process. It learns how to update the design so that the current solution advances along a user-specified trade-off direction, while a simple meta-algorithm periodically resets the policy, resamples starting designs from a continuously updated archive of non-dominated solutions, and adjusts step-size and penalty schedules. We evaluate MOON-RL on real-world actuator-design problems and additional convergence-hard constrained benchmarks, comparing against established evolutionary algorithms under matched evaluation budgets. In focused search scenarios, MOON-RL achieves competitive performance in the region of interest, and ablation studies show that both the RL-driven adaptive sampling process and the meta-algorithm contribute to this behaviour, suggesting that repurposing RL training as objective-space navigation is a viable building block for interactive, preference-guided design tools. Additional experiments show that the framework also accommodates adaptive non-RL samplers, while PPO remains a strong choice for fixed-target, preference-directed objective-space navigation.

Wed 11 NovMachine Learning
The gist
Many engineering problems involve deciding between several competing goals while making sure the design stays feasible. The paper presents MOON-RL, a new method that uses reinforcement learning to navigate through possible solutions by focusing search efforts based on user preferences. This approach adapts to each specific problem and learns how to improve designs toward desired trade-offs between objectives. The authors tested MOON-RL on real engineering tasks and found it competes well with traditional methods, especially when focusing on certain parts of the design space.
Open → 2611.15227v1

Python code speeds 3D design optimization using consumer graphics cards

An open source Python code for three-dimensional topology optimization in single precision on a consumer GPU

Abstract: Three-dimensional topology optimization solves linear systems with millions of unknowns at every design iteration. Consumer graphics cards run far faster in single than in double precision, and open codes for them mostly address minimum compliance. This educational article presents TOF3D, an open source Python code for density-based topology optimization in single precision on one consumer GPU. It solves four classes of problems: stress constrained minimum compliance, robust minimum compliance against manufacturing errors, compliant mechanisms and bone-like porous infill. The stiffness operator is applied without assembly, and the conjugate gradient method is preconditioned by geometric multigrid. Rounding the element matrix to single precision gave rigid body motions a spurious energy and changed compliances by up to 5.4%. Forming the element products from differences of nodal displacements reduced this error to $1.3\times 10^{-5}$ at no cost in time. Adjoint sensitivities agreed with finite differences to within $1.7\times 10^{-6}$, and the solutions agreed with Ansys Mechanical APDL to within $4.1\times 10^{-10}$ with the same element. On an RTX 3060 with 12 GB, one design iteration of a cantilever took 0.46 s with 0.5 million elements and 15 s with 33.5 million. On the same card and problem, an open GPU code that applies its operator in double precision took 3.7 and 21 s with 0.5 and 4.2 million elements and ran out of memory on larger meshes. Eight cases fixed in a protocol before the runs took 9 to 35 minutes each with 4.2 to 5.2 million elements.

Mon 9 NovComputational Engineering, Finance, and ScienceMathematical Software
The gist
Designing strong, lightweight 3D structures involves solving huge math problems that take a lot of computer power. The authors created a Python program called TOF3D that runs these problems much faster on common gaming graphics cards by using simpler number calculations. They tested it on several design types, from stress limits to bone-like structures, and showed it matches professional software results closely. This makes complex 3D design optimization more accessible and quicker on everyday computers.
Open → 2611.12027v1

GOPR-CAD improves text to CAD model generation accuracy and structure

GOPR-CAD: Graph-of-Operations Progressive Reasoning for CAD Generation

Abstract: Generating accurate CAD models requires substantial engineering expertise and careful control of geometry, topology, and mechanical constraints. Text-to-CAD aims to simplify this process, but current LLM-based methods often generate CAD programs directly. Language models remain unreliable when producing long code while coordinating coupled geometric, topological, and dimensional constraints. Consequently, executable programs may still produce structurally incorrect models, which execution rate and rendered appearance may fail to reveal. To address these limitations, we propose GOPR-CAD, an agentic Text-to-CAD pipeline based on Graph-of-Operations Progressive Reasoning. A language model acts as a decision agent over encapsulated CAD operations and progressively constructs an executable operation graph, which a deterministic compiler converts into the final CAD model. This separation requires no additional training and supports different language models. To evaluate structural fidelity, we construct MHCAD, a benchmark of 300 standard mechanical part requirements derived from Machinery's Handbook. Their explicit structures enable reference-free STEP/B-rep evaluation. GOPR-CAD achieves 82.7% Structural Yield on MHCAD, and 87.2% Structural Yield on an external CADPrompt subset.

Sun 8 NovArtificial Intelligence
The gist
Creating precise 3D models for machines requires expert knowledge and careful design. Writing computer code to make these models from text is tricky because errors can appear in complex details but may not be obvious in the final image. The authors developed GOPR-CAD, a method that builds CAD models step-by-step using a graph of operations, reducing mistakes. They tested it on a benchmark of mechanical parts and showed it produces structurally correct models more often than previous methods.
Open → 2611.11470v1

Mechanical engineering tools accessible through text and voice commands

Mechanical Engineering Skills: An Open Library of Agent Skills for Design, Analysis and Manufacturing

Abstract: Mechanical engineers use specialized tools for CAD, simulation, manufacturing and research, each with a distinct interface and learning curve. We present Mechanical Engineering Skills, an open library of 33 agent skills that makes these capabilities accessible through a single text or voice conversation. Each skill combines operating instructions, executable tools and verification procedures. A language model interprets the request, selects and coordinates skills, while deterministic tools perform computations and return checked results. Default workflows require no tool-specific interface training, local model execution or model fine-tuning; skills load on demand and install with one command. Nineteen skills adapt published or preprint research from our laboratory, including text-to-CAD, linkage synthesis, CFD setup, stress-field and lattice surrogates, equation discovery, additive-manufacturing planning and in-process monitoring. Fourteen additional skills support core engineering and education. We describe the skill format, design principles and a method for translating research into practical workflows. Five case studies with explicit evidence scopes and independent reruns demonstrate exact analytical agreement for lattice homogenization, rocket apogee predictions within 4% of stored OpenRocket references, an equation fit nine times more accurate than a cubic polynomial at an unseen temperature, and an end-to-end rehearsal of porosity monitoring. Controlled agent comparisons remain future work. The open library is available at https://github.com/BaratiLab/mechanical-engineering-skills.

Tue 3 NovMultiagent Systems
The gist
Mechanical engineers often need to use many complex software tools, each with its own way of working. The authors created a library of 33 special abilities, or "skills," that let people perform tasks like design, simulation, and manufacturing just by typing or speaking requests. These skills combine instructions, actual computations, and checks to make sure results are correct, all without needing to learn each software individually. They tested their system on real engineering problems and made the library openly available online.
Open → 2611.05758v1

Sciencevision benchmark measures ai understanding of 3d scientific data

ScienceVision: Can AI Observe and Reason Like a Scientist?

Abstract: Scientific discovery builds on accurate observations interpreted through domain knowledge and reasoning. For scientific 3D data, this requires understanding structures and spatial relationships, from protein contacts to anatomical organization. Existing multimodal benchmarks largely evaluate text and 2D images, while scientific 3D evaluations vary in representations and protocols across disciplines, limiting cross-disciplinary comparison. To assess these foundational capabilities, we introduce ScienceVision, a cross-domain benchmark for scientific 3D understanding and reasoning through expert-level visual question answering (VQA). We construct 250 questions, with 50 each from Biology, Chemistry, Medical Imaging, Mechanical CAD, and Architecture, through a pipeline combining synthetic question generation with domain-expert review and annotation. Each task pairs a native 3D artifact with a scientific question, a specified response format, and a task-specific reference answer, requiring domain knowledge to be applied to geometric or topological evidence. We evaluate 12 models on the same questions in three settings: visual question answering with native 3D artifacts accessed through an agent harness's file and code-execution tools; the same workflow augmented with expert-inspired viewer inspection and measurement tools exposed through the Model Context Protocol (MCP); and visual question answering from prescribed rendered 2D images using an agent harness. All settings use the same task-specific deterministic final-answer scoring. The inspection environment supports view changes, target isolation, and slice inspection. In this main comparison, the best mean answer score is 0.53 out of 1. Mean scores in the native-artifact workflow without additional MCP tools exceed those in the rendered-image workflow for every model, by 17.2 percentage points on average.

Mon 2 NovComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Scientific discovery often depends on understanding 3D structures, like proteins or organs, and using reasoning to interpret them. The authors created ScienceVision, a benchmark to test how well AI can answer expert-level questions about 3D scientific objects from various fields like biology and architecture. They made 250 questions paired with 3D models and tested 12 AI models in different ways, including interacting directly with the 3D data or just 2D images. Their results show AI still struggles, with the best average score only about halfway correct, but models do better when working directly with 3D data than with images.
Open → 2611.04087v1

Mesh2shell neural operator improves inverse shape optimization for physics driven design

Mesh2Shell Neural Operator for Inverse Shape Optimization

Abstract: Physics-driven design seeks high-performing geometries, which need not conform to a learned shape category. Parametric and latent-space approaches facilitate surrogate-based optimization, but restrict deformations to prescribed shape families or learned decoders. We introduce the Mesh-to-Shell Neural Operator (M2S-NO) as the mesh-to-shell component of a category-agnostic inverse shape optimization framework. We separate the explicit mesh used for design from the volumetric representation used for physics prediction. M2S-NO maps oriented surface samples to a surface-centered shell representation, such as TruncatedSDF or HeatSDF. A separate problem-specific PDE neural operator (PDE-NO) maps this representation to physical fields. Objective gradients update mesh vertices through both operators, without a latent shape decoder. Preconditioning and remeshing support free-form deformation, while fixed interfaces are controlled directly on the mesh. Optional shell-space proposals enable topology changes. We evaluate geometric matching, jet-engine brackets, and neutron moderators, with independent FEM and OpenMC evaluation. Relative to the best training designs, M2S-NO reduces maximum bracket displacement by 14.3% and increases neutron-sensor current by 13.8%. Optimization also succeeds from an out-of-distribution bracket initialization, demonstrating the framework's geometric flexibility.

Sun 1 NovMachine Learning
The gist
Designing shapes that perform well in physical tasks can be hard, especially when the shapes don't fit into known categories. The authors introduce a system called Mesh-to-Shell Neural Operator (M2S-NO) that turns a detailed surface mesh into a format better suited for physics calculations. This approach lets them optimize shapes more freely without being stuck to specific shape families. They tested it on things like jet-engine brackets and neutron moderators and found improvements in performance compared to existing designs.
Open → 2611.02127v1

Mechanism constraint structures improve learning from limited data

Efficient Learning of Mechanism Designs and Compositionality

Abstract: Learning mechanism behaviour requires a representation of how connected parts jointly constrain motion. We study whether exposing reusable constraint subassemblies improves prediction from limited data. Assur-KB represents planar mechanisms through irreducible modules, boundary interfaces, and solve dependencies while retaining source geometry. Our theoretical results characterize transfer through module interfaces and establish physical limits arising from missing interface information and accumulated sensitivity. To test the representation claim directly, the experimental design compares matched mechanism-curve pairs across training budgets within the same multilayer-perceptron family. This controlled comparison establishes the utility of the complete representation in the evaluated learning setting. Assur-derived features provide a geometric-mean $1.8\times$ advantage in sample efficiency over flattened adjacency and position inputs across budgets of 50-10,000 mechanisms. Separate experiments establish invariance under tested joint relabelings, higher valid-generation rates under dyadic composition, and a coarser structural index over 10.02 million mechanisms. In summary, the theory and experiments identify how physical constraint structure supports limited-data prediction and which interface conditions govern compositional reuse.

Thu 29 OctArtificial IntelligenceComputational Engineering, Finance, and Science
The gist
Predicting how mechanical parts move together is hard when data is limited. The authors study if breaking mechanisms into reusable pieces helps learning. They create a method called Assur-KB that captures these pieces and their connections using geometric and constraint information. Their experiments show this approach learns better and generalizes well with fewer samples than simpler methods. This work helps understand which physical connections matter most for reusing parts in learning mechanical behavior.
Open → 2610.40005v1

Computational design enables versatile walking movements for lego robots

Make it Walk: Computational Design of LEGO Walkers

Abstract: LEGO walkers are walking automata constructed from modular LEGO Technic bricks. They exhibit intriguing locomotion and are also highly reconfigurable through the modular Technic bricks, making them widely applicable in education, recreation, and robotics research. However, existing LEGO walkers are designed mostly by reusing existing single-actuator walking mechanisms. Although the locomotion is stable, their fixed walking gaits limit their adaptability and versatility. This paper presents the first computational solution capable of designing LEGO walkers that not only walk stably, but also support a variety of walking gaits. Our idea is twofold. First, we control the foot motion trajectory of each leg mechanically via a specifically-designed gear-linkage mechanism, in which we incorporate a pair of 3D-printed non-circular gears to work with a LEGO Technic mechanism. Second, we drive each leg by an independent motor and synchronize the timings of multiple leg motions via a simple yet adaptable control algorithm, enabling stable and versatile locomotion. Importantly, we take this modeling as a foundation to co-design the morphology and control of the LEGO walkers to meet the target locomotion and appearance. Leveraging our approach, we created a variety of LEGO walkers, demonstrating various walking gaits and appearances, and fabricated some of them to show their locomotion capability in the real world.

Wed 21 OctRobotics
The gist
LEGO walkers are robots made from LEGO Technic parts that can walk, but usually they have only one way of walking because they use just one motor and simple mechanisms. The authors created a new method that uses special 3D-printed gears combined with multiple motors to control each leg independently. This lets the LEGO walkers have different walking styles and more stable movement. They also designed a simple control system to coordinate the legs, allowing for more varied and adaptable walking designs.
Open → 2610.29505v1

Neural model speeds material-efficient 3D lattice refining by 5000 times

SLIM: Learning an Operator for Material-Efficient 3D Lattice Refinement

Abstract: Lattice inverse-design methods can generate cells that match prescribed effective properties, but property feasibility does not imply material efficiency. Removing redundant material from an existing lattice while preserving its homogenized elasticity ordinarily requires solving a separate constrained topology optimization problem for each cell, making large-scale refinement computationally expensive. We introduce SLIM (Structural Lightweighting via Implicit Mapping), a neural lattice-refinement model that replaces this per-instance iterative optimization with a single forward prediction. SLIM uses a dual-octree implicit network to predict the signed-distance field of a lightweight lattice and is trained on input--output pairs generated by property-constrained topology optimization. To improve stiffness preservation, we use homogenization sensitivities computed on the optimized target to estimate how residual voxel errors in a prediction affect its homogenized stiffness, and penalize this estimated change during training. Once trained, SLIM requires no topology optimization, homogenization analysis, or sensitivity evaluation during prediction. On the held-out test set of 906 lattices, SLIM achieves a mean relative volume-fraction reduction of 15.90%, a lightweighting success rate of 90.51%, and a mean normalized aggregate TO-target error of 0.636%, while reducing the average per-lattice generation time from 2516.0 s with direct TO to approximately 0.5 s. These results show that SLIM provides a fast neural surrogate for repeated topology-optimization-based refinement of 3D lattices.

Sat 17 OctGraphics
The gist
Making 3D lattice structures lighter without losing their strength usually takes a long time because it involves complex step-by-step adjustments for each design. The authors created SLIM, a neural network that learns from previous optimized designs to quickly predict how to remove excess material while keeping the lattice stiff. This approach cuts down the time from over 40 minutes to about half a second per design. Their model also keeps most of the original strength and reduces material by nearly 16% on average.
Open → 2610.24459v1

Optimizing spring design for variable manufacturing and material factors

Robust Optimization of Spring Design under Variable Manufacturing Tolerances

Abstract: A reliable assessment of an optimizer robustness requires tracking controlled changes in parameters to identify sources of algorithmic weakness. Such an approach was applied to the problem of designing tension/compression springs with three continuous variables describing the spring geometry. Three additional independent binary parameters reflect material variability, manufacturing-related geometric deviations, and an additional safety margin. Without expanding the decision space, these parameters can be combined in eight ways to generate variants that allow for direct comparison. In this study we distinguish between robustness effects and the dimension of the problem, which allows tracking changes in feasibility while keeping the nominal mass objective constant. Seven optimization methods and eight hybridized their variants are used for the analysis. The hybridization mechanism applies the operator selected by the prediction procedure presented in Section 3. All methods are evaluated under the same experimental conditions. Each method is run thirty times for each variant, with a maximum of 30000 function evaluations permitted per run. The final quality assessment takes into account the geometry of the feasibility region, search trajectories, performance variations across landscapes and the computational cost of fixed objectives. Together, these factors allow us to determine the quality of the solution, reproducibility, feasibility control, and the effectiveness of optimization. An interesting observation was that hybridization can mitigate cost or feasibility losses associated with a specific configuration. While it compensates for a specific weakness in the underlying mechanism, it does not provide universal resilience.

Sat 3 OctNeural and Evolutionary Computing
The gist
Designing springs that work well even when materials or manufacturing vary is a challenge. The paper studies how different optimization methods perform when spring design parameters and conditions change in controlled ways. The researchers use eight variations to test for robustness without adding complexity and run each method many times to compare their effectiveness. They find that combining methods can reduce some weaknesses but does not guarantee overall reliability. This helps understand how to better optimize spring design under uncertainty.
Open → 2610.04656v1

Differentiable 3d model links visual data to solid mechanics simulation

A differentiable Lagrangian-coupled 3D Gaussian Splatting-SPH model for forward simulation and inverse analysis in solid mechanics

Abstract: Recent advances in generative world models have increased interest in digital models that reproduce both the appearance of real objects and their response to physical interaction. Three-dimensional reconstruction techniques, including 3D Gaussian Splatting, capture detailed surface geometry and appearance from images and videos. However, extending these representations beyond plausible animation to mechanically interpretable models for constitutive behavior, boundary conditions, and inverse parameter identification remains less explored. In this work, a differentiable Lagrangian-coupled 3DGS-smoothed particle hydrodynamics (SPH) model is proposed for forward simulation and inverse analysis of deformable solids. The observed object is first reconstructed from multi-view calibrated visual dataset as a 3DGS rendering model. An envelope-based procedure then generates an independent SPH support for the solid-mechanics model, avoiding the direct use of rendering primitives as mechanical particles. A reference-configuration Lagrangian transfer maps SPH deformation to Gaussian positions and covariances, thereby coupling the physical model and the image observation model while preserving a differentiable computational path. The SPH formulation supports linear elastic, hyperelastic, and Kelvin--Voigt viscoelastic responses, together with fixed, free, and Robin-type boundary conditions. Numerical studies validate the SPH response against finite-element results, assess accuracy and efficiency against a conventional model using Gaussian centers as surface SPH particles, and demonstrate forward simulations on beam, bridge, and liver-shaped examples. Inverse analyses further estimate constitutive and boundary parameters from rendered deformation observations, including noisy cases, demonstrating the feasibility of the proposed model for mechanics-based parameter identification from image data.

Sat 3 OctComputer Vision and Pattern Recognition
The gist
Capturing both how objects look and how they behave when touched or deformed is tricky. The authors present a new method that first reconstructs an object’s detailed 3D shape and appearance from images, then models how that object physically deforms using a physics-based method called smoothed particle hydrodynamics (SPH). Their approach connects the visual model and physical simulation in a way that can be differentiated, meaning it can be used to figure out material properties or boundary conditions from observed deformations. They tested their method on examples like beams and shapes resembling organs, showing it can simulate and also estimate physical parameters even with noisy data.
Open → 2610.04336v1

Reduced modeling speeds simulations of mechanical metamaterials with complex patterns

Reduced order modeling for micromorphic computational homogenization of mechanical metamaterials with patterning fluctuation fields

Abstract: Mechanical metamaterials owe some of their exotic effective properties to microstructural instabilities such as buckling and pattern transformation. Their fine-scale geometry, combined with the interplay of local and nonlocal effects, renders direct numerical simulation (DNS) prohibitively expensive, if not intractable. Micromorphic computational homogenization~\citep{Rokos2019} has been proposed to make macroscopic simulations feasible: a representative volume element (RVE) carrying patterning fluctuation fields resolves the microscale, while an effective micromorphic continuum describes the macroscale. Such simulations nevertheless remain costly, since the RVE problem and its associated tangent problems must be solved at every macroscopic integration point, which becomes prohibitive, especially in three dimensions. We therefore propose a reduced order model for the microscopic problem, combining proper orthogonal decomposition with a hyperreduction method tailored to the micromorphic setting. Two numerical examples quantify the reduced basis and hyperreduction errors and discuss the offline costs and attainable online speed-ups. The results show that this approach can enable engineering-scale large deformation analysis of mechanical metamaterials.

Tue 29 SeptComputational Engineering, Finance, and Science
The gist
Simulating materials with tiny repeating structures that fold or buckle is often too slow to do on big models directly. The paper presents a way to simplify these detailed simulations by capturing their key patterns in fewer calculations, making them faster. The authors combine techniques that reduce the complexity of the detailed parts while still keeping the important behaviors. This approach can help engineers study how these special materials deform on larger scales more efficiently.
Open → 2609.38416v1

Topology optimization method improves pressure-actuated compliant mechanisms

A Comparative Study on Robust Topology Optimization of Design-Dependent Pressure-Actuated Compliant Mechanisms with Quadrilateral Elements

Abstract: This paper presents a comparative study of compliant mechanisms generated using a robust topology optimization technique involving design-dependent pressure loads. Design domains are parameterized using standard and higher-order quadrilateral elements. Both eroded and blueprint configurations are considered. A min-max optimization model combined with an output-spring method is employed to extremize the mechanisms' output displacements. A volume and a strain energy constraint are applied to the blueprint and the eroded designs, respectively. The optimization process is executed using the method of moving asymptotes. Numerical experiments are performed to optimize the pressure-actuated inverter and gripper mechanisms using Q4, Q8, and Q9 elements, and the results are compared. The research highlights how quadrilateral element selection influences both the resulting topologies and performance characteristics.

Mon 28 SeptComputational Engineering, Finance, and Science
The gist
Building machines that bend and move precisely using pressure can be tricky because how the pressure applies depends on the shape itself. This paper looks at different ways to break down the design area into small squares or shapes to figure out the best design that works well even if the pressure changes a bit. The researchers tested different types of these shapes and compared the results for two specific machines: one that flips motion and one that grips. They showed that the choice of these design shapes affects the final machine’s structure and how well it performs.
Open → 2609.34341v1

Generative AI helps design adaptive gravity balancing mechanisms

Modeling and Generative-AI-Based Design of Load-Adaptive Gravity Balancing Mechanisms

Abstract: Load-adaptive gravity balancing mechanisms (LA-GBMs) can accommodate various loading conditions by passively changing their characteristics in response to payload variations. However, their design is difficult because both the desired mechanism motion and static equilibrium under variable payloads must be satisfied simultaneously. This study proposes a general design methodology for LA-GBMs that does not depend on specific mechanism architectures or mechanical elements. The necessary conditions for the potential fields of LA-GBMs are formulated, and two general forms are derived: an affine form representing the effect of payload mass and a factorized form representing state transitions associated with load adaptation and gravity balancing. These forms are then provided to generative AI as design requirements to generate candidate potential functions. The generated functions are analytically verified in terms of their conformity to the two general forms and the conditions required for valid LA-GBMs. Furthermore, the obtained potential functions are decomposed into individual terms, and an example of a method for constructing an LA-GBM by combining springs, counterweights, and function-generating linkage mechanisms is presented. By using potential functions as an intermediate representation, the proposed framework enables the generation of LA-GBM design candidates without prescribing a mechanism architecture in advance. Mechanical realizability and manufacturability of the generated potential fields remain important issues for future work.

Fri 25 SeptRobotics
The gist
Designing mechanisms that can automatically adjust to different weights is hard because they need to move in specific ways and stay balanced. The authors propose a new method that uses math formulas to describe how these mechanisms should behave, then uses AI to create possible designs. They check the AI-made designs carefully to make sure they work in theory, and show how such designs could be built from springs and weights. This approach lets designers explore many possibilities without starting with a fixed mechanism shape.
Open → 2609.31386v1

Neural network speeds up design of shapes with consistent gradients

KATOsuper: Surrogate-accelerated neural topology optimization with sensitivity-consistent Fourier neural operators

Abstract: Topology optimization (TO) remains computationally intensive due to repeated finite element analysis (FEA) evaluations required at each iteration. While neural network-based surrogates offer potential acceleration, existing approaches often suffer from gradient inconsistency between predicted objectives and sensitivities, leading to optimization instability. This work presents KATOsuper, an objective-agnostic framework that couples neural-reparameterized topology optimization with a Sensitivity-Consistent Fourier Neural Operator (SC-FNO). The framework employs the forward_split architecture, which derives deployed sensitivities via automatic differentiation through the predicted objective field and thereby preserves consistency between the predicted objective and the gradient used for optimization. The case studies include three 2D benchmark problems and three 3D structures considering compliance or stress minimization. A physics-informed multi-channel input encoding with Fourier position embedding enables resolution-invariant learning, supporting zero-shot extrapolation beyond the training resolution, with useful performance at moderate scaling factors and topology-preserving exploration at up to 64x without retraining. The framework extends to 3D through KATO3D, featuring novel KANConv3D blocks with learnable B-spline activations. KATOsuper demonstrates 15--110x deployment-time speedup over MATLAB baselines while maintaining competitive optimality, with the clearest gains observed in complex 3D and stress-optimization cases. The insight that sensitivity direction matters more than magnitude enables robust optimization even with approximate physics evaluation, extensible to other differentiable physics-driven design objectives.

Wed 23 SeptComputational Engineering, Finance, and ScienceArtificial IntelligenceMachine Learning
The gist
Designing optimal shapes and structures can take a long time because it requires many detailed physics calculations at each step. The authors introduce KATOsuper, a method that uses a special type of neural network to predict both the design quality and its sensitivity consistently, helping the design process run much faster without losing accuracy. Their approach works on both 2D and 3D problems, can handle different resolutions without retraining, and achieves significant speed improvements, especially for complex designs. This method also shows that having the right direction for changes in design matters more than exact amounts, allowing robust optimization even when physics calculations are approximate.
Open → 2609.27216v1

Comparing multimaterial design methods with honeycomb patterns

Multimaterial Topology Optimization using SIMP, DMO, and gSF: A comparative study with Honeycomb tessellations

Abstract: This paper presents a comparative study of multimaterial topology optimization (MMTO) using the extended SIMP, Discrete Ma- terial Optimization (DMO), and generalized shape functions (gSF) ap- proaches. The design domain is parametrized using hexagonal elements. Each element has six neighboring elements, thereby improving element connectivity and yielding a relatively uniform local mesh structure. This characteristic reduces mesh-related effects on the optimized designs com- pared with conventional triangular and quadrilateral discretizations. Struc- tural compliance is minimized at the prescribed volume fractions. The optimization is performed using the method of moving asymptotes. The resulting optimized topologies are compared in terms of material distri- bution, structural performance, convergence behavior, and the character- istics of the obtained material interfaces. The comparative investigation provides insights into the working principles and performance of the ex- tended SIMP, DMO, and gSF interpolation schemes for MMTO.

Tue 22 SeptComputational Engineering, Finance, and Science
The gist
Designing objects with different materials can make them stronger or lighter, but it’s tricky to find the best layout. This paper looks at three different ways to arrange materials when designing shapes made of many tiny hexagons, like a honeycomb. The authors tested how well each method builds strong designs and how they manage the borders between materials. Their study helps understand which method works better depending on the design goals.
Open → 2609.25976v1

Topology optimization automatically tunes design hyperparameters during optimization

Bilevel Optimization of Topology and Hyperparameters (BOTH)

Abstract: Topology optimization (TO) represents a significant step towards automating the design process: given a working simulation, TO can produce a viable prototype at the press of a button by differentiating the simulation and iteratively improving the design. In practice, however, TO is riddled with ``magic numbers''---hyperparameters whose tuning significantly affects the outcome. Finding the right values typically requires not only deep problem-specific knowledge but also extensive trial-and-error. While practitioners can use surrogate-assisted hyperparameter optimization as an alternative, this approach requires strictly limiting the number of hyperparameters through careful problem formulation. Here, we propose differentiating TO itself using automatic differentiation. This yields ``hypergradients'' that allow us to tune these hyperparameters in tandem with the primary optimization. We show that evaluating just one or two steps of TO is sufficiently informative and that the method scales favorably to thousands of hyperparameters at an expense comparable to only a few standard TO runs. We demonstrate this approach on stress-constrained and compliance problems, with the latter utilizing a neural parameterization of the density field.

Fri 18 SeptMachine Learning
The gist
Designing objects often involves picking settings called hyperparameters, which are usually hard to choose and need lots of trial and error. The authors show how to automatically adjust these settings while designing, by calculating how small changes affect the design quality. This approach uses information from just a few optimization steps and can handle many hyperparameters efficiently. It helps create better designs by tuning settings alongside the main design process without extra guesswork.
Open → 2609.21758v1