AI-Powered Generative Design System for Mechanical Parts

A client receives a CAD file of a part, but the design is over-engineered: safety factor of 3 when 1.5 is required. Long manual optimization begins—iterations, recalculations, new prototypes. A month of engineer work, and mass reduced by only 10%. We offer a different approach: AI finds the optimal shape in hours, not weeks. Topology optimization can reduce mass by 30-40% without losing strength (SIMP, classic method).

Example: for an aircraft bracket weighing 2.3 kg with safety factor 3, we reduced mass to 1.4 kg without strength loss. Manual optimization would take 3 weeks, AI did it in 6 hours. Material savings — 0.9 kg, which at aluminum price of $2.5/kg saves $2.25 per part, and for a series of 10,000 parts — $22,500. Design time reduced by 10x, making AI generative design 10 times faster than traditional manual optimization.

We develop a generative design system that analyzes loads and boundary conditions, then generates a structure with minimal possible weight under given strength requirements. Stack — Python, PyTorch, Scipy, OpenCASCADE. Applying machine learning in engineering (ML for CAD) automates routine tasks. Result — up to 40% material savings and 5-10x acceleration of the design cycle.

How Generative Design Works: From SIMP to VAE

Topology Optimization with SIMP (Time-Efficient)

The classic method is SIMP (Solid Isotropic Material with Penalization). The algorithm iteratively distributes material in a discrete grid, aiming to minimize compliance under a given volume. Suitable for problems with clear loads: brackets, frames, supports.

import numpy as np
from scipy.sparse import lil_matrix
from scipy.sparse.linalg import spsolve

class TopologyOptimizer:
    def __init__(self, nelx=60, nely=30, volfrac=0.5, penal=3.0, rmin=1.5):
        self.nelx = nelx
        self.nely = nely
        self.volfrac = volfrac
        self.penal = penal
        self.rmin = rmin

    def optimize(self, load_case, boundary_conditions, max_iterations=100):
        x = np.full((self.nely, self.nelx), self.volfrac)
        xold = x.copy()
        for iteration in range(max_iterations):
            U = self._finite_element_analysis(x, load_case, boundary_conditions)
            dc = self._sensitivity_analysis(x, U)
            dc = self._filter_sensitivity(x, dc)
            x = self._oc_update(x, dc)
            change = np.max(np.abs(x - xold))
            xold = x.copy()
            if change < 0.01:
                break
        return x
    # ... methods omitted for brevity

Why SIMP Isn't Suitable for Complex Parts?

SIMP is sensitive to initial conditions and can get stuck in local minima. For problems with multiple loads or nonlinear constraints, neural network methods are better — they generate diverse options from which the engineer selects the best.

How VAE Generates New Designs?

We use a variational autoencoder (VAE), trained on a dataset of 2,000 optimized designs. Input is a vector of physical conditions (loads, boundaries), output is a new shape with desired properties. This yields hundreds of options in seconds. Variational autoencoders were proposed by Kingma and Welling (Auto-Encoding Variational Bayes).

import torch
import torch.nn as nn

class DesignGeneratorVAE(nn.Module):
    def __init__(self, latent_dim=64, design_resolution=64):
        super().__init__()
        self.latent_dim = latent_dim
        res = design_resolution
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 32, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(32, 64, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 128, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.Flatten()
        )
        encoder_out_size = 128 * (res // 8) ** 2
        self.fc_mu = nn.Linear(encoder_out_size, latent_dim)
        self.fc_logvar = nn.Linear(encoder_out_size, latent_dim)
        self.condition_proj = nn.Linear(16, latent_dim)
        self.decoder_input = nn.Linear(latent_dim * 2, 128 * (res // 8) ** 2)
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(64, 32, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 1, 4, stride=2, padding=1),
            nn.Sigmoid()
        )
        self.res = res

    def generate(self, conditions, n_samples=1):
        with torch.no_grad():
            z = torch.randn(n_samples, self.latent_dim)
            c = self.condition_proj(conditions.expand(n_samples, -1))
            zc = torch.cat([z, c], dim=1)
            h = self.decoder_input(zc)
            h = h.view(n_samples, 128, self.res // 8, self.res // 8)
            return self.decoder(h)

Integration with CAD (via Python-OCC)

The obtained density matrix is converted to a 3D mesh via Marching Cubes, smoothed, and exported to STL. Then import into any CAD system for final refinement.

from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeSolid
from OCC.Core.TopoDS import TopoDS_Shape
import trimesh
import numpy as np

def density_to_mesh(density_matrix, threshold=0.5):
    from skimage.measure import marching_cubes
    density_3d = np.stack([density_matrix] * 10, axis=-1)
    verts, faces, normals, _ = marching_cubes(
        density_3d, level=threshold, spacing=(1.0, 1.0, 1.0))
    mesh = trimesh.Trimesh(verts=verts, faces=faces, vertex_normals=normals)
    mesh = trimesh.smoothing.filter_laplacian(mesh, iterations=10)
    return mesh

def export_to_stl(mesh, output_path):
    mesh.export(output_path)

How to Implement AI Generative Design: Step-by-Step Guide

1. Audit current designs and loads — collect data on boundary conditions, materials, safety factors.
2. Choose method — SIMP for clear tasks, VAE for multi-variant generation.
3. Develop model — implement algorithm, train VAE on your dataset (if required).
4. Generate and validate — obtain variants, verify with finite element analysis (NASTRAN, Ansys).
5. Integrate with CAD — convert to STL/STEP, import into SolidWorks, CATIA, or Fusion 360.
6. Test and refine — finalize design, deliver documentation (model card).

What Results Can Be Achieved with Generative Design?

Comparison of SIMP and VAE Methods

What Our Work Includes (Deliverables)

We deliver turnkey projects with the following items:

• Documentation: model card, retraining instructions, and usage guide.
• Source code: complete AI pipeline and integration scripts.
• Integration: export to STL/STEP and CAD environment setup.
• Support: 12 months of updates and troubleshooting.
• Training: optional session for your engineering team.

Our Experience and Guarantees

We have been in AI engineering for over 7 years, completed 20+ projects in aviation, automotive, and medical industries. We provide a guarantee on algorithm performance in your conditions. If needed, we retrain the model on new data. All source code and model card are delivered to the customer.

Timeline

Basic SIMP prototype — 1–2 weeks. Full VAE system — 4–6 weeks. Timelines are calculated individually after problem analysis. We have experience accelerating projects through transfer learning and quantization (INT8) — p99 latency reduced by 2x.

Evaluate Potential for Your Part

In projects, we achieve 35-40% mass reduction for aluminum and titanium parts. If your current design process takes weeks of manual optimization, contact us for a demonstration. Our AI for structural optimization and neural network shape generation enable rapid iteration. Automated design engineering with AI reduces manual effort. Request an audit of your part and receive a demo calculation in 2 days — get in touch.