-
-
Landing Page
-
Robot Dog Hardware 3D Breakdown
-
Mechanical Arm Hardware 3D Breakdown
-
Drone Hardware 3D Breakdown
-
Community Project Section
-
Step by Step Build Guide
Rivet
From an idea to a 3D hardware design, real components, wiring, and the code to build it.
Inspiration
At almost every hackathon we've attended, we've seen people building some genuinely cool hardware projects. Robots, drones, custom devices, and things that actually interact with the physical world.
Our team is mostly software-focused. We know how to build applications, work with APIs, and write code, but when it comes to actually building hardware, we wouldn't even know where to start.
Even something as simple as building a robot means figuring out which components you need, whether they're compatible, how everything connects, what you need to buy, and how to program it.
And most tools either expect you to already understand hardware or only help with one part of the process.
We kept coming back to one question:
Why can't building hardware be as approachable as building software?
That became Rivet.
We started with people like us, but quickly realized that students, makers, and even small startups face similar problems when trying to turn an idea into something physical.
We wanted to make that process accessible to anyone with an idea, not just people who already understand CAD, electronics, and mechanical engineering.
What it does
Rivet turns a picture, sketch, or natural-language description into an interactive 3D hardware design.
You can upload a reference image or simply ask:
"Build me a small robot that can avoid obstacles."
Rivet interprets the request, generates three different 3D designs, and constructs actual geometry based on the intended shape, proportions, and functionality.
These aren't just generated images.
Rivet builds individual 3D parts, renders the models from six angles, compares them against the original reference, and automatically revises geometry that doesn't look right.
For supported hardware projects, Rivet also figures out what you need to actually build them:
real components · purchasing links · 3D printing files · wiring · assembly instructions · firmware · simulation
You can inspect each component in the 3D viewer, explore an exploded assembly, see how the parts connect, and understand what you need to purchase versus manufacture yourself.
For example, if you're designing a custom RC car, Rivet can generate the printable chassis, including STL/STEP files, dimensions, material recommendations, and printing guidance.
For supported programmable hardware, it also provides starter firmware and pin mappings.
You can then ask:
"Make the chassis wider, move the sensor higher, and add larger wheels."
Rivet updates the geometry, regenerates the affected fabrication files, reruns the relevant checks, and saves a new revision.
More complex objects can still be generated as 3D concepts, with unsupported engineering claims clearly identified.
We didn't want to build another AI tool that just shows you what something could look like.
We wanted to help you understand what it would actually take to build it.
That became the core of Rivet:
imagine → design → validate → print → build
How we built it
System architecture
┌─────────────────────────────────────────────────────────────────────┐
│ Rivet │
│ ┌──────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │
│ │Text / Image │ │3D Design │ │Design / Inspect / Edit │ │
│ │Input │ │Studio │ │ │ │
│ └──────────────┘ └──────────────┘ └───────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ Visual Understanding │
│ ┌──────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │
│ │OpenAI │ │Multiview │ │Structured Intent & │ │
│ │Vision │ │References │ │Design Requirements │ │
│ └──────────────┘ └──────────────┘ └───────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
│
┌───────────────┴────────────────┐
▼ ▼
┌────────────────────────────────┐ ┌────────────────────────────────┐
│ Generative Design │ │ Hardware Engineering │
│ │ │ │
│ ┌────────────┐ ┌─────────────┐ │ │ ┌────────────┐ ┌─────────────┐ │
│ │3 Design │ │Structured │ │ │ │Real Parts │ │Component │ │
│ │Candidates │ │DesignSpec │ │ │ │Catalog │ │Selection │ │
│ └────────────┘ └─────────────┘ │ │ └────────────┘ └─────────────┘ │
└────────────────────────────────┘ └────────────────────────────────┘
│ │
└───────────────┬────────────────┘
▼
┌─────────────────────────────────────────────────────────────────────┐
│ Geometry Compilation │
│ ┌──────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │
│ │OpenCascade │ │Parametric & │ │Assembly Constraints & │ │
│ │CAD Kernel │ │Freeform CAD │ │Mechanical Validation │ │
│ └──────────────┘ └──────────────┘ └───────────────────────────┘ │
│ │
│ Geometry • Attachments • Collision • Stability │
│ │
│ VALID / NEEDS REVIEW / INVALID │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ Visual Evaluation │
│ ┌──────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │
│ │Six-Angle │ │AI Visual │ │Targeted Geometry │ │
│ │Rendering │ │Critic │ │Revision │ │
│ └──────────────┘ └──────────────┘ └───────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
│
┌───────────────┴────────────────┐
▼ ▼
┌────────────────────────────────┐ ┌────────────────────────────────┐
│ 3D Studio │ │ Hardware Outputs │
│ │ │ │
│ ┌────────────┐ ┌─────────────┐ │ │ ┌────────────┐ ┌─────────────┐ │
│ │Interactive │ │Exploded │ │ │ │BOM & │ │Wiring & │ │
│ │Assembly │ │View + Edits │ │ │ │Purchasing │ │Firmware │ │
│ └────────────┘ └─────────────┘ │ │ └────────────┘ └─────────────┘ │
└────────────────────────────────┘ └────────────────────────────────┘
│ │
└───────────────┬────────────────┘
▼
┌─────────────────────────────────────────────────────────────────────┐
│ Fabrication & Export │
│ ┌──────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │
│ │Per-Part │ │STL / STEP │ │Materials, Dimensions & │ │
│ │Print Packs │ │CAD Exports │ │3D Printing Guidance │ │
│ └──────────────┘ └──────────────┘ └───────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
│
▼
Versioned Designs
│
└──────▶ Edit → Recompile → Revalidate
One rule mattered from the beginning:
AI designs the hardware. Our geometry and engineering engines determine what can actually be constructed and verified.
A model looking correct doesn't automatically mean it's buildable.
How AI generates the 3D models
We didn't want Rivet to generate an image and pretend it was a finished 3D design.
The actual geometry needed to exist.
OpenAI analyzes the uploaded reference, identifying its shape, proportions, components, and distinctive features.
We then generate three structured design candidates using a typed DesignSpec that describes individual bodies, dimensions, materials, and attachments.
Our Python engine uses OpenCascade and Manifold3D to compile those specifications into actual 3D geometry, including extrusions, lofts, Boolean operations, curved surfaces, and freeform shapes.
Each candidate is rendered from six angles and evaluated against the original reference using a multimodal visual critic.
If something is wrong, the critic identifies the affected parts and Rivet generates targeted geometry revisions.
We preserve the best valid design rather than accepting every change.
The loop becomes:
reference → structured design → CAD geometry → render → compare → revise
How Rivet handles hardware engineering and 3D printing
Generating something that looks like a robot is one thing.
Figuring out whether someone can actually build it is a completely different problem.
For supported hardware, Rivet connects designs to real cataloged components and validates electrical requirements, mounting constraints, clearances, and mechanical stability.
Our initial engineering workflow focuses on a differential-drive rover with an ESP32, motors, motor driver, distance sensor, and supporting electronics.
Rivet produces the BOM, component references, purchasing links, wiring, pin mappings, and PlatformIO starter firmware. We also built a simplified simulation for obstacle-avoidance behavior.
But not every part of a project needs to be purchased.
Rivet separates commercial components from custom fabricated parts like enclosures, chassis, brackets, and mounts.
Users can select a fabricated component and export its STL/STEP geometry, alongside dimensions, material guidance, print orientation, and other relevant printing information.
If the design changes, those fabrication files are regenerated from the updated geometry.
We also check supported manufacturing constraints, including wall thickness and clearances.
One important decision was that AI never certifies its own hardware designs.
If a specification is missing, a component doesn't fit, or something hasn't been physically verified, Rivet reports that uncertainty instead of pretending everything works.
Why we think Rivet can scale
We're starting with students, hackathon participants, robotics clubs, and independent makers.
But the problem we're solving goes much further than helping someone build their first robot.
Small hardware startups, product designers, educators, and independent inventors all need to move from an idea to a design, source components, and figure out how to manufacture custom parts.
Today, that process often involves several disconnected tools.
We see Rivet becoming a single starting point for that workflow.
Our initial model is a self-serve platform for individuals, with a path toward paid team workspaces for schools, labs, startups, and engineering teams.
Longer term, we want to connect designs directly to component suppliers, 3D printing services, and manufacturers.
That creates opportunities for subscriptions, team plans, and sourcing or fabrication integrations.
The part we're most interested in is that Rivet understands the actual structure behind every design.
It knows the geometry, components, constraints, printable parts, and revisions.
As we expand our engineering capabilities and component catalog, that same architecture can support more types of physical products.
We don't see Rivet as just an AI robot generator.
We want it to become the starting point for creating physical products.
Challenges we ran into
The hardest part was getting the generated models to actually resemble the original reference.
Our first versions could produce valid 3D geometry, but the result sometimes looked nothing like what we asked for.
We realized that reducing an image to a text description lost too much visual detail.
We changed the pipeline so the geometry-generation model could inspect the reference directly, and the revision model could compare actual renders before modifying the design.
We also had to handle invalid geometry, overlapping parts, incorrect attachments, and unstable assemblies.
That led us to build deterministic checks and repair logic rather than trusting every AI-generated design.
The other challenge was keeping everything synchronized.
Changing one part needed to update not just the 3D viewer, but also its engineering checks, fabrication files, and relevant build outputs.
Accomplishments we're proud of
Rivet works as one connected loop:
image → AI design → CAD geometry → visual refinement → engineering checks → 3D assembly → fabrication and build outputs
The part we're most proud of is that the generated geometry isn't disconnected from everything else.
You can inspect individual components, understand how they connect, modify the design, and export the actual custom parts needed to build it.
We started Rivet because we wanted to make hardware projects ourselves.
We ended up building something that could help a much wider group of people do the same.
What we learned
We learned that generating valid geometry doesn't mean you've generated the right geometry.
A model can pass CAD checks and still look nothing like the intended object.
We also learned how many decisions go into hardware development that we normally don't think about when building software.
Power, mounting, compatibility, manufacturing, and physical assembly all introduce challenges that don't exist in a typical web application.
Building Rivet made us appreciate the hardware projects we've seen at hackathons a lot more.
What's next
We want to expand Rivet beyond our initial rover workflow to drones, robotic arms, custom electronics, and more complex physical products.
That includes larger component catalogs, verified manufacturer CAD models, collaborative workspaces, and more advanced simulations.
Longer term, we want users to be able to design a physical product, understand what it requires, and order the components and fabricated parts needed to build it directly through Rivet.
Rivet started with a simple idea: you shouldn't need to understand hardware engineering just to start building something physical.
We want to see how far we can take that.
Log in or sign up for Devpost to join the conversation.