| Version | 0.3 — renamed RobotStudio (working name) |
| Owner | Arunabh Das, Platform6ix Inc. |
| Status | Draft for review |
| Date | 2026-08-27 |
| Related | Competitive, Vendor, Pricing & Customer Landscape report (Aug 2026) · robotstudio-prototype.html · CLAUDE_CODE_BRIEF.md |
| Changes in 0.2 | Product renamed from RoboSimOS to RoboCAD. Views renamed Design / System / Live Run. §7.2 rewritten to specify drag-and-drop snapping with visual feedback and sidebin part swapping. §7.10 Live Run added as P0. Roadmap and metrics updated. |
RobotStudio is a vendor-neutral desktop application for designing application-specific robots and robot cells from a library of real, purchasable parts. A user assembles a cell in 3D from catalog parts, gets immediate compatibility checking (mounting, electrical, torque/payload, bus/protocol), runs a task-level simulation (reach, collision, cycle time, throughput, power budget), and exports a priced bill of materials plus URDF/MJCF/USD/STEP for downstream tools.
It is "KiCad for robot cells": the parts library is the schematic symbol library, the compatibility checker is DRC/ERC, the task simulation is SPICE, and the BOM is the Gerber/pick-and-place output.
MVP wedge: a single cell type — a cobot pick-and-place / sortation cell for warehouse and logistics (arm + gripper + camera + compute + fixed base/table + conveyor or tote context). The MVP must let a system integrator produce a quotable cell design with a priced BOM in under one working day.
What the MVP is not: a physics simulator competing with Isaac Sim or Gazebo, a facility-level discrete-event simulator competing with FlexSim or Emulate3D, or a hardware marketplace. It exports to the former and feeds the latter.
Integrators, automation consultants, and SMB operators quote warehouse robot cells with a fragmented stack: SolidWorks or Onshape for geometry, vendor STEP downloads, spreadsheets for BOMs and pricing, a separate simulator (Visual Components, RoboDK, or an OEM tool) for reach and cycle time, and manual checks that parts actually fit together electrically and mechanically. The pre-sale design-to-quote phase is the longest single phase of the engineer-to-order sales cycle and is staffed by scarce senior engineers.
Roboticists face the same problem from the other side: getting a real-parts assembly into a simulator means hand-authoring URDF/MJCF, fixing mates and joints, and re-deriving mass and inertia — the reason tools like onshape-to-robot exist.
No existing product combines a neutral parts catalog, snap-together assembly, compatibility checking, a live priced BOM, and simulator export:
- Vention has the loop (catalog → design → simulate → BOM → order) but is a walled garden for its own hardware, now moving toward physical AI (US$110M Series D, Jan 2026, NVIDIA participating).
- RoboDK / Visual Components are multi-vendor but have no catalog, BOM, pricing, or compatibility checking; Visual Components is quote-priced and heavy.
- UR Studio / ABB RobotStudio / KUKA.Sim are single-OEM.
- Isaac Sim / Gazebo / MuJoCo / Webots are physics engines with no parts, BOM, or checker.
- Magzor attempted drag-and-drop mechatronics for makers (2009–2019), never raised venture funding, and stalled — evidence that the concept needs a commercial wedge, not a maker audience.
| Finding | Consequence for MVP |
|---|---|
| Vention proves catalog-driven cell design with live BOM/pricing is commercially viable (4,000+ factories, >$100M CAD run rate) | Copy the loop; differentiate on neutrality and openness |
| Vendor-pays catalog model is standard in ECAD/MCAD (TraceParts, CADENAS, SnapEDA, Ultra Librarian) but always quote-priced and monetizes lead-gen + analytics more than flat listing | Vendor monetization is Phase 3, not MVP. MVP must capture design-intent analytics from day one so there is something to sell later |
| STEP is ubiquitous; URDF/kinematic data is fragmented and community-maintained | The part-package spec must carry kinematics/electrical metadata that vendors don't publish. Seed catalog is a curation effort, not a scrape |
| Integrators use FlexSim/AnyLogic/Plant Simulation for facility throughput; OEM tools for arm OLP; SolidWorks for geometry | Simulate at the cell level only; export to their existing tools rather than replace them |
| Physical-AI capital flows to robot brains and humanoids; simulation/design tooling is a small category; warehouse robotics deal value fell 28.5% in 2025 | Plan for bootstrapped or lightly funded execution; near-term revenue from integrator seats |
| Job postings and vendor marketing confirm the pre-sale quoting bottleneck is real and staffed by senior engineers | The MVP success metric is time-to-quotable-design, not simulation fidelity |
| Isaac Sim is Apache-2.0 and outputs are unrestricted; Onshape→USD→Isaac bridges are live (2026) | USD export is a first-class MVP deliverable; RobotStudio is a front door to Isaac, not a rival |
| AAS (Asset Administration Shell) and OPC UA Robotics are the emerging vendor-neutral component metadata standards | Align the part-package schema vocabulary with AAS/OPC UA from the start to make vendor adoption cheaper |
- An integrator can assemble a cobot pick/sort cell from catalog parts and reach a quotable design in < 1 working day (baseline: 3–10 days).
- Every design is validated by a compatibility checker that catches the errors that currently surface at build time (wrong mounting pattern, undersized PSU, over-payload, incompatible bus).
- Every design produces a priced BOM with vendor part numbers and indicative lead times.
- Every design exports cleanly to URDF, MJCF, USD, and STEP, and loads in Isaac Sim and Gazebo without manual editing.
- The part-package format is open and documented, with a validator, so vendors and the community can author parts without us.
- Usage telemetry captures which parts are searched, placed, swapped, and exported, so vendor analytics exist before the vendor portal does.
- Facility-level throughput simulation (multi-cell, WMS/WES logic, fleets).
- High-fidelity contact physics (grasping is a kinematic attach in Live Run), or RL training.
- Offline programming / robot program export to OEM controllers.
- Mobile manipulation (AMR base + arm) — deferred to v1.1.
- Vendor self-serve portal and billing.
- Real-time multi-user collaboration.
- Web/browser build (architecture must not preclude it).
- Ordering/procurement integration.
| Persona | Role | Job to be done | Current tools | Buys? |
|---|---|---|---|---|
| Sam, sales/applications engineer at a mid-size integrator (primary) | Turns an RFQ into a concept design + quote | Prove the cell reaches, cycles, and fits budget, fast enough to bid | SolidWorks, vendor STEP, Excel, sometimes RoboDK or Visual Components | Yes — Integrator tier |
| Priya, robotics engineer at a picking/AMR startup | Prototype a new cell or end-effector configuration and get it into simulation | Avoid hand-authoring URDF; compare grippers/cameras quickly | Onshape/Fusion, onshape-to-robot, Isaac/MuJoCo | Yes — Pro tier |
| Marcus, operations lead at an SMB 3PL | Sanity-check feasibility and ballpark cost before engaging an integrator | "Can a cobot cell handle 400 picks/hr on this tote profile, and what does it roughly cost?" | Vendor sales calls, spreadsheets | Free tier; converts integrators |
| Vendor product manager (Phase 3) | Get parts specified into designs; see demand signals | Distribution + design-intent analytics + RFQ leads | TraceParts/CADENAS, UR+ | Yes — platform fee (later) |
- Sam opens RobotStudio, picks the "Cobot pick-and-place / sortation" template.
- Sets task parameters: tote dimensions, SKU mass range (0.2–3 kg), target throughput (400 picks/hr), pick zone and place zone footprint.
- Drags a UR10e from the sidebin over the pedestal; the pedestal's base bolt pattern lights up, the arm ghost snaps into it with a click, and the connection is confirmed. Drags a Robotiq 2F-85 onto the arm — the tool flange glows, the gripper snaps, and the checker confirms the ISO 9409-1-50-4-M6 match. Adds a RealSense D455 on a bracket, a Jetson Orin, a 48 V PSU, and a conveyor segment.
- The checker flags: gripper payload at 3 kg items plus 1.1 kg gripper exceeds the UR10e's rated payload at full reach — suggests UR16e or lighter gripper. Sam drags a Robotiq Hand-E from the sidebin onto the 2F-85; the swap target highlights, he drops, and the Hand-E takes the 2F-85's place on the flange with connections carried over.
- Runs task simulation: reach envelope covers both zones; cycle time 7.8 s → 460 picks/hr theoretical, 390 at 85% utilization; power budget 640 W peak; no collisions with conveyor.
- Reviews BOM: 14 line items, US$78,400 indicative, longest lead 6 weeks (camera bracket custom).
- Exports: PDF design summary for the quote, BOM CSV, STEP for the mechanical team, USD for a colleague running Isaac Sim.
Elapsed: ~3 hours.
Priority: P0 = MVP must-have, P1 = MVP if time allows, P2 = post-MVP.
| ID | Requirement | Priority |
|---|---|---|
| CAT-1 | Bundled seed catalog of ≥ 200 parts across ≥ 8 vendors covering the wedge: arms (UR e-Series, FANUC CRX, Doosan, Kinova), grippers (Robotiq, OnRobot, Schunk), cameras (RealSense, Zivid, Basler), compute (Jetson, Advantech), power (Mean Well, Puls), structure (igus, Misumi, 80/20, McMaster), conveyors (Dorner, Interroll), totes/racks (generic + Akro-Mils) | P0 |
| CAT-2 | Faceted search and filter: category, vendor, payload, reach, voltage, bus, price, lead time | P0 |
| CAT-3 | Part detail panel: 3D preview, specs, interfaces, price, lead time, datasheet link, license | P0 |
| CAT-4 | Local user library: import a STEP/glTF and author a part package via a guided form | P1 |
| CAT-5 | Catalog updates delivered as signed package bundles over HTTPS; app works fully offline with cached catalog | P1 |
| CAT-6 | Part verification badge (vendor-verified vs. community vs. RobotStudio-curated) shown everywhere a part appears | P0 |
The Design tab is where the cell is built. The sidebin (parts catalog, left) is the source of every part; the 3D stage is the target. Two gestures cover almost all of the work: drag a part onto a structure to snap it, and drag a part onto an existing part to swap it. Both must feel physical: the user should never wonder whether a drop will land.
Interface model. Every part exposes zero or more typed interfaces from interfaces.json (e.g. mech.flange.iso9409-1-50-4-m6, mech.bolt.ur-base, mech.rail.t-slot-40, mech.mount.quarter-20). An interface has a role (host or mount), a transform on the part, a cardinality, and an optional orientation constraint (fixed, 4-fold, free-spin). A drop is a snap when a mount on the dragged part is compatible with a free host on a part in the scene. Compatibility is decided by the rule engine (§7.4), not by geometry, so vendors control what their parts can attach to.
| ID | Requirement | Priority |
|---|---|---|
| ASM-1 | Drag a part from the sidebin (mouse or touchpad; also + button for keyboard users, which enters a placement mode) into the stage. A translucent ghost of the part follows the cursor at its real scale, oriented by its primary mount. |
P0 |
| ASM-2 | Candidate highlighting on drag start. The moment a drag begins, every free, compatible host interface in the scene is highlighted with a ring marker and a soft glow; incompatible hosts stay dim. If there are no compatible hosts, the ground plane shows a "free placement" hatch and the status bar explains why (e.g. "No open ISO 9409 flange in the cell"). | P0 |
| ASM-3 | Snap capture. When the ghost comes within a capture radius (default 120 mm in scene units, scaled by zoom so it's ~24 px on screen) of a compatible host, the ghost jumps to the exact mated transform, the host ring turns solid in the accent color, a connector line is drawn between mount and host, and a snap tick plays (respects reduced-motion and can be muted). Moving out of the radius releases the ghost back to the cursor. | P0 |
| ASM-4 | Drop = commit. Dropping while captured creates the part and a Connection. Dropping outside any capture radius, on a part with no compatible host, or on the ground places the part free (ASM-8) only if it has a ground-mountable interface or no interfaces; otherwise the drop is rejected with a bounce-back animation and a one-line reason ("Grippers attach to a tool flange"). |
P0 |
| ASM-5 | Orientation choice. For hosts with 4-fold or free-spin constraints, the captured ghost can be rotated in steps with R/scroll while held; the current index or angle is shown next to the cursor. |
P0 |
| ASM-6 | Multiple candidates. When more than one host is within the capture radius, snap to the nearest; Tab while captured cycles to the next candidate. Hovering a host ring for 300 ms shows its name and what's already on it. |
P0 |
| ASM-7 | Drop into the tree. Dragging a part onto a row in the cell tree snaps it to that part's first free compatible host, with the same highlight rules; the tree row highlights during hover. | P1 |
| ASM-8 | Free placement for parts without a mating host (conveyors, totes, fencing, scanners): translate/rotate gizmo, grid snap (10 mm default), floor-plane constraint, and edge/face snapping to other free parts at 5 mm. | P0 |
| ASM-9 | Detach. Dragging an already-placed part off its host detaches it (connection removed, dependents come along); dropping it on another compatible host re-snaps. Delete removes a part and its dependents after confirming when dependents exist. |
P0 |
| ID | Requirement | Priority |
|---|---|---|
| SWP-1 | Swap target detection. While dragging a sidebin part over an existing part of the same category (arm over arm, gripper over gripper, camera over camera, PSU over PSU), the existing part is outlined in the accent color, a "Swap" chip appears at the cursor, and the checker previews the post-swap result inline (e.g. "Payload OK · 2 fewer USB ports"). | P0 |
| SWP-2 | Drop = swap. Dropping performs an in-place swap: the new part inherits the old part's host connection, transform, orientation index, user label, and — where interfaces match — its child connections (a new arm keeps its gripper if the flange type matches; otherwise the child is detached and listed in the toast). | P0 |
| SWP-3 | Swap with incompatible host. If the new part cannot attach to the old part's host (e.g. FANUC CRX onto a UR-only pedestal plate), the outline turns red, the chip reads "Won't fit: needs FANUC base plate," and the drop is rejected. The checker offers the adapter or alternate host as a fix. | P0 |
| SWP-4 | Swap from the checker and BOM. Every checker fix that replaces a part, and every "Alternates" row in the BOM (BOM-5), performs the same swap operation as SWP-2 so behavior is identical regardless of entry point. | P0 |
| SWP-5 | Swap history. A swap is a single undoable command. Telemetry records part.swap with from/to ids (§7.8) — this is the highest-value vendor signal. |
P0 |
| SWP-6 | Compare before swap. Right-click a sidebin part while a same-category part is selected → "Compare with selected" opens a two-column spec/price/lead diff; "Swap" from that panel performs SWP-2. | P1 |
| ID | Requirement | Priority |
|---|---|---|
| FBK-1 | Snap and swap feedback uses three visual channels together: host ring/outline (accent), a connector line during capture, and a status-bar sentence. Colour alone is never the only signal. | P0 |
| FBK-2 | After a successful snap or swap the new part pulses once and the checker panel re-evaluates within 100 ms; new violations slide in at the top. | P0 |
| FBK-3 | The sidebin marks parts already in the cell ("In cell ×2") and disables drag for singletons that would be redundant, offering "Swap into cell" instead. | P0 |
| FBK-4 | Drag can be cancelled with Esc at any time; the ghost fades and nothing changes. |
P0 |
| FBK-5 | The ghost, rings, and connector render on top of the scene with depth-tested occlusion cues (dimmed when behind geometry) so snapping works in cluttered cells. | P1 |
| ID | Requirement | Priority |
|---|---|---|
| ASM-10 | Cell tree: hierarchical (host → mounted parts), rename, group, hide/show, lock; selection synced with the stage. | P0 |
| ASM-11 | Joint-aware posing: drag arm joints within limits (or use the pose HUD) to check reach interactively. | P0 |
| ASM-12 | Undo/redo, copy/paste, multi-select, and duplicate-with-connections. | P0 |
| ASM-13 | Templates: pre-built starting cells (pick-and-place, sortation, palletizing). | P0 |
| ASM-14 | Measure tool, section view, footprint overlay. | P1 |
| ASM-15 | Custom geometry import (STEP/glTF) as a passive environment object. | P1 |
Acceptance for this section: a first-time user completes golden-path steps 3–4 (§6) with no free placement and no rejected drops other than the intentional payload swap, in under 10 minutes, without reading documentation.
| ID | Requirement | Priority |
|---|---|---|
| SYS-1 | Auto-generated node graph of power and data connections derived from part interfaces (PSU → controller → arm; camera → compute via USB-C; gripper ↔ arm via tool I/O) | P0 |
| SYS-2 | User can connect/disconnect ports; unconnected required ports are flagged | P0 |
| SYS-3 | Power tree with per-rail load, PSU headroom, and cable gauge suggestion | P1 |
| SYS-4 | Export system diagram as SVG/PNG | P1 |
| ID | Rule family | Examples | Priority |
|---|---|---|---|
| CHK-1 | Mechanical interface | Flange standard mismatch, bolt pattern, mounting orientation | P0 |
| CHK-2 | Payload and moment | Gripper + max item mass vs. arm rated payload; CoG offset vs. moment limit at reach | P0 |
| CHK-3 | Reach and workspace | Pick/place zones outside reachable envelope; base too close to zone | P0 |
| CHK-4 | Electrical | Voltage mismatch, PSU overloaded (sum of peak draws > rated), missing PSU, connector type mismatch | P0 |
| CHK-5 | Data/bus | Protocol mismatch (EtherCAT vs. Modbus TCP), insufficient ports on compute, USB bandwidth for camera count | P0 |
| CHK-6 | Collision (static) | Placed parts intersect; arm at home pose intersects environment | P0 |
| CHK-7 | Safety envelope | Reach envelope intersects human walkway zone without fencing/scanner (advisory) | P1 |
| CHK-8 | Sourcing | Part end-of-life, lead time exceeds project date, vendor region availability | P1 |
Rules are data-driven (declarative, versioned, shipped with the catalog) so new vendors and part classes don't require app updates. Each violation has severity (error/warning/info), an explanation, and where possible a suggested fix (swap part, add part, move part).
| ID | Requirement | Priority |
|---|---|---|
| SIM-1 | Scenario definition: pick zone(s), place zone(s), item mass/size distribution, target throughput, shift hours | P0 |
| SIM-2 | Kinematic reach analysis with joint limits; reachable-volume visualization | P0 |
| SIM-3 | Cycle-time estimate from motion profile (joint velocity/accel limits, approach/retreat, grasp dwell) — analytical, not learned | P0 |
| SIM-4 | Throughput and utilization projection with configurable efficiency factor | P0 |
| SIM-5 | Swept-volume collision check along the pick→place path against environment | P0 |
| SIM-6 | Power budget: peak and average draw, kWh/shift, PSU headroom | P0 |
| SIM-7 | Animated playback of the cycle in the 3D view | P1 |
| SIM-8 | Sensitivity sweep: throughput vs. item mass, vs. zone distance | P2 |
| SIM-9 | Rigid-body dynamics via Rapier for drop/tip checks | P2 |
Fidelity statement shown in the UI: results are feasibility-grade estimates (target ±15% on cycle time vs. OEM tools); export to Isaac/RoboDK/OEM simulators for validation-grade results.
| ID | Requirement | Priority |
|---|---|---|
| BOM-1 | Live BOM: vendor, part number, qty, unit price, extended price, lead time, verification status, license | P0 |
| BOM-2 | Price provenance (vendor list, distributor, RobotStudio estimate) and date stamp | P0 |
| BOM-3 | Export BOM as CSV/XLSX | P0 |
| BOM-4 | Design summary report (PDF): renders, task parameters, checker results, simulation results, BOM, assumptions | P0 |
| BOM-5 | Alternates: for each part, show compatible alternates with price delta | P1 |
| BOM-6 | Currency selection (USD/CAD/EUR) | P1 |
| ID | Format | Direction | Priority |
|---|---|---|---|
| IO-1 | .robosim project (JSON + assets, git-friendly) |
R/W | P0 |
| IO-2 | URDF + meshes (glTF/STL), with SRDF collision groups | Export | P0 |
| IO-3 | MJCF | Export | P0 |
| IO-4 | USD (single-file stage, Isaac-compatible articulation) | Export | P0 |
| IO-5 | STEP assembly | Export | P0 |
| IO-6 | glTF scene | Export | P0 |
| IO-7 | STEP / glTF part geometry | Import (as environment or new part) | P1 |
| IO-8 | Import existing URDF as a part or sub-assembly | Import | P2 |
Acceptance: exported URDF loads in Gazebo Harmonic; exported USD loads in Isaac Sim 5.x with articulation intact; exported MJCF loads in MuJoCo 3.x. All three verified in CI against the seed catalog templates.
| ID | Requirement | Priority |
|---|---|---|
| TEL-1 | Opt-in usage telemetry (default on for free tier with clear disclosure, off for Enterprise): part searches, placements, swaps, checker violations by part, exports, BOM totals by category | P0 |
| TEL-2 | No project geometry or customer names leave the machine; part-level events only | P0 |
| TEL-3 | Internal analytics dashboard (not user-facing in MVP): top searched parts, top swapped-out parts, unmet searches | P1 |
| ID | Requirement | Priority |
|---|---|---|
| ACC-1 | Free tier: full assembly, checker, simulation, export; watermark on PDF report | P0 |
| ACC-2 | Pro tier license key: no watermark, private local library, alternates | P0 |
| ACC-3 | Integrator tier: white-label report branding, multi-currency, priority support | P1 |
| ACC-4 | Offline license validation with 30-day grace | P1 |
Live Run is the difference between "this cell should work" (the analytical cycle check, §7.5) and "watch this cell work." The user places the assembled cell in an environment, presses Play, and watches it execute the task against a flowing stream of items in simulated time with live metrics. It is P0 for the MVP.
| ID | Requirement | Priority |
|---|---|---|
| LR-1 | Live Run is the third view tab (Design / System / Live Run). Entering it freezes the assembly (tree read-only, no drag/snap/swap) and shows the cell inside an environment. | P0 |
| LR-2 | Environments are .rse packages (same discipline as .rsp: manifest, glTF, semantic zones, license). MVP ships bay-sortation-a (conveyor source and sink, inbound totes, 2–6 sort lanes, walkway zones) and bay-empty. |
P0 |
| LR-3 | Placement. The cell is dropped into the environment with the same snap feedback as §7.2: the environment exposes anchor hosts (floor anchor grid, conveyor tie-in), the cell ghost snaps to them, and the placement is a single undoable command. | P0 |
| LR-4 | Transport bar: Play, Pause, Step (one control tick), Reset, speed 0.25×–8×, a scrubber over the recorded run, simulated clock. Deterministic: same project + same seed = same run. | P0 |
| LR-5 | Item stream driven by the §7.5 scenario: mass/size distribution, arrival rate, tote fill. Items are rigid bodies on the conveyor; the camera "sees" them in its frustum; the sort rule (mass band for MVP) assigns lanes. | P0 |
| LR-6 | Behaviour is a data-described state machine per cell: Idle → Perceive → Plan → Approach → Grasp → Transport → Release → Retreat, timings from performance.json, joint-space trajectories bounded by the arm's limits. Grasp is a kinematic attach: success if rated grip force ≥ item mass × safety factor and the approach pose is reachable; otherwise a logged miss. |
P0 |
| LR-7 | Live metrics: picks/hr (rolling and cumulative), cycle-time histogram, utilisation, misses with reasons, conveyor backlog, peak/average power, kWh so far; refreshed every 250 ms wall time. | P0 |
| LR-8 | Event log: timestamped, filterable (grasp.miss, reach.fail, collision, backlog.overflow); clicking an event scrubs to it and highlights the parts involved. |
P0 |
| LR-9 | Collision: swept-volume check every control tick against environment and static parts; a collision pauses the run, raises a checker error, and highlights the pair. | P0 |
| LR-10 | Recording: every run is recorded (state per tick + events) into the project so scrubbing works after Pause and the run can be attached to the design summary. Ring buffer, default 10 simulated minutes. | P0 |
| LR-11 | Leaving Live Run returns to Design; the last run's summary appears in the Simulation panel and design summary. | P0 |
| LR-12 | Fidelity label identical to §7.5: "feasibility estimate, not a safety assessment." An assumptions panel states what is not modelled (grasp contact physics, vision latency, fleets). | P0 |
Engineering constraints: fixed-timestep simulation in the core (physics 240 Hz, control 60 Hz, decoupled from render); compact binary snapshots to the UI, never per-frame JSON; real time at 1× on a 2021 MacBook Air with ≤ 40 dynamic bodies; a golden-run determinism test is the acceptance gate.
The format is the platform. It is published under an open license (CC-BY-4.0 for the spec, MIT for the validator and reference reader) so vendors and the community can author parts independently.
part.rsp (zip)
├── manifest.json # id, vendor, part number, name, version, license, verification
├── geometry/
│ ├── visual.glb # display mesh (glTF 2.0)
│ ├── collision.glb # simplified collision mesh
│ └── source.step # optional B-rep for STEP export
├── kinematics.json # links, joints, limits, velocity/accel, mass, inertia, CoG
├── interfaces.json # mechanical, electrical, data interfaces with typed connectors
├── electrical.json # rails, nominal/peak draw, supply range, connector types
├── performance.json # payload/moment curves, reach, repeatability, grip force
├── commercial.json # list price (currency, date, source), lead time, region, EOL
├── datasheet.pdf # optional
└── thumbnail.png
Design principles:
- Interfaces are typed and named (e.g.,
mech.flange.iso9409-1-50-4-m6,elec.dc.48v,data.ethercat,data.usb3-c). The compatibility checker reasons over interface types, not geometry. - Vocabulary aligned with AAS submodel templates and OPC UA Robotics where they exist, so vendors who already publish AAS digital nameplates can map fields directly.
- Every file is optional except manifest, visual geometry, and interfaces. A vendor can publish a STEP-only part in an hour; kinematics and performance can be added later or curated by RobotStudio.
- Verification levels recorded in the manifest:
community,robosim-curated,vendor-verified. - License field is mandatory and enforced: parts with no-redistribution terms are not bundled in the seed catalog.
Seed catalog sourcing order: (1) vendors with explicit permissive CAD terms and existing open URDFs (UR, Robotiq, RealSense, Clearpath, Robotis), (2) community models from robot_descriptions honoring each license, (3) vendors approached in Phase 0 with a written hosting/redistribution agreement.
┌──────────────────────────────────────────────────────────┐
│ Tauri desktop shell (macOS, Windows, Linux) │
│ ┌────────────────────────────────────────────────────┐ │
│ │ React + Vite + TypeScript │ │
│ │ • React Three Fiber 3D editor (@react-three/drei) │ │
│ │ • Catalog browser, BOM, checker panel, sim panel │ │
│ │ • System view (React Flow) │ │
│ └───────────────▲────────────────────────────────────┘ │
│ │ Tauri commands / events (JSON) │
│ ┌───────────────▼────────────────────────────────────┐ │
│ │ robosim-core (Rust crate, no UI dependencies) │ │
│ │ • scene graph + assembly model │ │
│ │ • part registry + .rsp loader/validator │ │
│ │ • rule engine (compatibility checker) │ │
│ │ • kinematics (reach, IK, motion-profile timing) │ │
│ │ • collision (Parry) / optional dynamics (Rapier) │ │
│ │ • exporters: URDF/SRDF, MJCF, USD, STEP, glTF │ │
│ │ • BOM + pricing engine │ │
│ └────────────────────────────────────────────────────┘ │
│ Sidecars: STEP kernel (OpenCASCADE via opencascade-rs, │
│ isolated process to contain LGPL), USD writer │
└──────────────────────────────────────────────────────────┘
│ HTTPS (catalog sync, telemetry, license)
┌───────────────────▼──────────────────────────────────────┐
│ Catalog + license service (Django + DRF, Postgres, │
│ object storage; Procrastinate for ingestion jobs) │
└──────────────────────────────────────────────────────────┘
Key decisions:
- Core is UI-free and wasm-compilable. Everything in
robosim-coremust build forwasm32so the web version is a frontend port, not a rewrite. Rapier and Parry already support wasm. - Physics: Parry for collision and swept volumes in MVP; Rapier for optional dynamics; MuJoCo bindings deferred (it's an export target, not a runtime dependency).
- STEP handling is isolated in a sidecar process to keep OpenCASCADE's LGPL boundary clean for a proprietary shell.
- USD export is written directly from a minimal
.usdawriter in Rust for MVP (avoids linking the full OpenUSD C++ stack); validated against Isaac Sim in CI. - Rule engine evaluates declarative rules (JSON, versioned with the catalog) over typed interfaces; rules are hot-loadable without an app release. The same engine answers the Design tab's drag-time questions ("which hosts can this mount attach to?", "what happens if I swap A for B?") via a
previewcall, so snap candidates and swap previews are always consistent with the checker. - Snapping is a core operation. Capture radius, candidate ranking, mated transform, orientation index, and swap inheritance are computed in
robotstudio-core; the frontend only draws ghosts, rings, and connector lines from the returned candidate set. - Project files are JSON plus referenced assets, designed to diff cleanly in git.
- Catalog service reuses the existing house stack; MVP scope is catalog bundle distribution, telemetry ingestion, and license validation only.
- Part — immutable, versioned
.rsppackage identity (vendor/partno@version). - Interface — typed connector on a part (mechanical/electrical/data), with a transform and cardinality.
- Instance — a placed part in a project: part ref, transform, joint state, user label.
- Connection — a mated pair of interfaces (mechanical snap or electrical/data link).
- Zone — task volume (pick, place, human walkway, keep-out).
- Scenario — task parameters for simulation.
- Rule — declarative check with selector, predicate, severity, message, fix suggestion.
- Violation — rule result bound to instances/connections.
- SimResult — reach coverage, cycle time, throughput, power, collisions, timestamped with catalog version.
- BOMLine — derived from instances; price provenance and date.
- Single window, three views: Design (default), System, Live Run. Checker, Simulation, and BOM are persistent side panels; the design summary is a modal summoned from the toolbar, never an overlay on the stage.
- Errors are actionable. Every violation names the parts involved, explains the rule in one sentence, and offers a fix button where possible.
- Snap first, free placement second. The default interaction is drag-onto-interface with candidate hosts lit before the cursor gets there; free placement is explicit and explained.
- Swapping is dragging. Replacing a part is the same gesture as adding one — drag from the sidebin onto the part you want to replace — and it's the same command whether it comes from the stage, the tree, the checker, or the BOM.
- Show the money. BOM total and longest lead time are always visible in the status bar.
- Fidelity honesty. Simulation results carry an explicit "feasibility estimate" label and a link to export for validation-grade tools.
- Keyboard parity with common CAD conventions (G/R/S transforms, Esc cancel, Ctrl-Z).
- Palette and typography follow the house design language; no purple/indigo/cyan.
- 15 discovery interviews with integrators/consultants; ≥ 8 confirm quoting is a > 2-day bottleneck and would trial a tool.
- 3–5 design-partner integrators signed (LOI or paid pilot).
- 5 vendors approached with the analytics/lead-routing pitch; ≥ 2 indicate willingness to pay for verified listing once user volume exists; ≥ 3 grant written redistribution rights for CAD.
| Metric | Target |
|---|---|
| Time from template to quotable design (design-partner measured) | < 1 working day, median < 4 hours |
| Checker precision on design-partner review | ≥ 90% of flagged errors judged real |
| Rejected drops per golden-path run (excluding the intentional payload swap) | 0 (median), ≤ 2 (p90) |
| Live Run at 1× real time on reference machine, sortation template | 100% of runs; golden-run hash stable across 20 runs and 2 OSes |
| Export success (URDF→Gazebo, USD→Isaac, MJCF→MuJoCo) on all templates | 100% in CI |
| Seed catalog | ≥ 200 parts, ≥ 8 vendors, ≥ 60% with kinematics/performance data |
| Design partners producing a real customer quote with RobotStudio | ≥ 3 |
| Weekly active designers (free + paid) at launch + 90 days | 150 |
| Paid seats at launch + 90 days | 20 |
- ≥ 40% of catalog searches are discovery (category/attribute) rather than exact part number — mirrors the SnapEDA pattern that vendors pay for.
- Swap events concentrate on a few part classes (grippers, cameras) — indicates competitive placement value.
| Risk | Likelihood | Impact | Mitigation |
|---|---|---|---|
| Seed catalog is thin or wrong; checker gives false confidence | High | High | Curate rather than scrape; verification badges; design partners review every part in their bids; start with ≥ 60% curated kinematics coverage |
| Vendors refuse redistribution of CAD | Medium | High | Written agreements in Phase 0; ship spec + local import so users can add vendor parts themselves; link-out to vendor download where terms forbid bundling |
| Vention opens its catalog to third parties | Low–Medium | High | Openness is the moat: publish the spec, validator, and reference reader early; support importing Vention STEP |
| Simulation results distrusted by integrators | Medium | Medium | Label as feasibility-grade; publish validation against RoboDK and ABB's RobotStudio on the templates; export path for validation |
| Scope creep toward physics/OLP | High | Medium | Non-goals list enforced; export instead of build |
| Solo-founder bandwidth | High | High | MVP is one cell type, one workflow; catalog curation contracted; Claude Code milestone-gated protocol for implementation |
| OpenCASCADE LGPL | Low | Medium | Sidecar process isolation; legal review before release |
| Telemetry perceived as surveillance by integrators | Medium | Medium | Part-level events only, documented publicly; Enterprise tier off by default |
| Phase | Duration | Scope | Exit criterion |
|---|---|---|---|
| 0 — Discovery & seed | 6 weeks | Interviews, design-partner LOIs, vendor outreach, spec v0.1, 50-part hand-curated catalog, clickable prototype | Phase 0 gate metrics met |
| 1 — MVP | 5 months | All P0 requirements including Design-tab snap/swap (§7.2) and Live Run (§7.10); 200-part catalog; three templates; two .rse environments; CI export validation; golden-run determinism test; Pro licensing |
Design partners produce real quotes; launch metrics |
| 1.5 — Hardening | 6 weeks | P1 requirements prioritized by design-partner feedback; Integrator tier; alternates | 20 paid seats |
| 2 — Mobile manipulation | 3 months | AMR bases, larger .rse environment library (racks, floor plans; SITU scan import), transport scenarios in Live Run, multi-cell runs |
Second template family in use by partners |
| 3 — Vendor portal + platform fee | 3 months | Self-serve .rsp ingestion, verification workflow, analytics dashboard, RFQ routing, billing |
≥ 3 paying vendors, ≥ 1 renewal |
| 4 — Web + collaboration | 3 months | wasm core, browser frontend, shared projects, comments, versioning | Web MAU ≥ desktop MAU |
| 5 — Sim-to-real | ongoing | ROS 2 system-graph export, controller config templates, procurement handoff | Lead-gen revenue live |
Pivot thresholds: if integrator seats outsell vendor fees after Phase 3, treat the catalog as a loss leader (KiCad model). If vendors pay but seats don't convert, lean into the TraceParts model and deepen analytics.
- Wedge confirmation: fixed cobot pick/sort cell (proposed, lower Vention overlap on AMR side deferred) vs. mobile manipulation first. Decide after Phase 0 interviews.
- Pricing: Pro at US$49–99/seat/month and Integrator at US$249–399/seat/month are placeholders; benchmark against RoboDK (~US$3k perpetual) and Visual Components (quote, ~€4–12k/yr).
- Spec license and governance: who owns
.rsplong-term — Platform6ix, or a foundation-style steward to reassure vendors? - Pricing data source: vendor list prices vs. distributor APIs (Digi-Key/Mouser cover electronics; robotics pricing is mostly quote-based). MVP may ship with "indicative" pricing only.
- Telemetry default for the free tier: on-with-disclosure vs. opt-in. Affects vendor analytics volume.
- Name clearance — blocking before any public use. "RobotStudio" is the name of ABB's offline-programming and simulation product (ABB RobotStudio®), a direct competitor profiled in §2 and §16. ABB holds registered trademarks on the mark in the software class in major jurisdictions. Shipping under this name risks a cease-and-desist, App Store / notarization rejection, domain and social-handle unavailability, and buyer confusion with the incumbent. Treat "RobotStudio" strictly as an internal working name; run a trademark search (USPTO, CIPO, EUIPO) and clear a final name before Phase 0 outreach, the design-partner LOIs, the public
.rspspec site, or any signed build.
- vs. Vention: neutral catalog across all vendors, open format; export instead of lock-in.
- vs. RoboDK / Visual Components: parts, BOM, pricing, and compatibility checking they don't have; feasibility-grade sim instead of OLP.
- vs. Isaac Sim / Gazebo / MuJoCo: the front door — assemble from real parts, export a correct description.
- vs. FlexSim / Emulate3D / AnyLogic: cell-level, hours not weeks; feeds their facility models.
- vs. Onshape + onshape-to-robot: no CAD skills needed; parts carry kinematics and electrical metadata CAD doesn't.