RoboForge — Design. Simulate. Train. Deploy.

An AI-powered robotics studio that brings robot design, physics simulation, reinforcement learning, and real-world deployment into a single browser-based platform.

Inspiration

Robotics is transforming industries, but getting started remains expensive and technically challenging. Building and testing robots often requires costly hardware, powerful GPU workstations, complex simulation software, and specialized engineering knowledge.

For students, researchers, startups, and small businesses, these barriers can make robotics experimentation inaccessible.

We asked ourselves a simple question:

What if anyone could design a robot, control it using everyday language, train it in a realistic physics environment, and deploy its intelligence to real hardware — all from a web browser?

That question inspired RoboForge.

Our vision is to make robotics development more accessible, intelligent, and affordable by bringing the entire robotics workflow into one unified platform.

Instead of purchasing a robot just to test an idea, users can experiment virtually, validate behavior, improve performance, and prepare for real-world deployment.

Build virtually. Learn intelligently. Deploy confidently.

RoboForge Studio

What It Does

RoboForge is an AI-powered, browser-based robotics development environment built around the MuJoCo physics engine.

It combines robot modeling, natural-language control, autonomous navigation, computer vision, reinforcement learning, and deployment tools into a single interactive studio.

1. Control Robots Using Natural Language

Users can communicate with robots using simple English instructions such as:

  • "Drive in a square."
  • "Navigate to the red box."
  • "Build a warehouse and patrol it."
  • "Move the robotic arm to the target position."

An AI agent interprets these instructions, selects appropriate tools, and converts them into validated simulation actions.

This makes robotics experimentation more accessible to users without extensive programming experience.

2. AI-Powered Mission Planning

RoboForge supports complex, multi-step instructions through its autonomous Mission Planner.

For example, when a user enters:

"Build a warehouse and patrol it."

The system can generate a warehouse environment, identify navigation targets, calculate collision-free paths using A* search, and execute the mission inside the simulator.

The entire process is visualized, allowing users to observe robot movement and planned routes.

3. Physics-Based Robot Simulation

Unlike platforms that rely on predefined animations, RoboForge uses the MuJoCo physics engine to simulate robot dynamics.

The simulation supports physical interactions, collision detection, joint movement, friction, gravity, and actuator behavior.

For a differential-drive rover, linear and angular velocities are calculated as:

[ v = \frac{r(\omega_R+\omega_L)}{2} ]

[ \omega = \frac{r(\omega_R-\omega_L)}{L} ]

Where:

  • (r) is the wheel radius.
  • (L) is the distance between the wheels.
  • (\omega_L) and (\omega_R) are the left and right wheel angular velocities.

These equations allow wheel commands to produce physically meaningful rover movement.

4. Live Reinforcement Learning

One of RoboForge's most distinctive capabilities is its live reinforcement learning environment.

Using Proximal Policy Optimization (PPO), users can train robots to improve their behavior through repeated interactions with simulated environments.

Multiple training environments run in parallel, and their live robot positions are displayed as transparent ghost robots inside the visualization.

These ghosts are not animations or fabricated demonstrations. They represent the actual parallel environments participating in training.

Users can observe how robots explore, learn, and improve throughout the training process.

5. AI-Powered Robot Vision

RoboForge integrates onboard camera feeds with vision-language models.

This enables robots to interpret visual information from their simulated surroundings and supports tasks involving object identification, environmental understanding, and visually guided commands.

6. Robot Design and Kinematics

The integrated Robot Builder provides tools for creating and configuring robotic systems.

It supports URDF import and export, forward kinematics, inverse kinematics, joint manipulation, and configurable sensors such as LiDAR, IMU, and cameras.

Users can work with multiple robot categories, including:

  • Differential-drive rovers
  • Quadcopters
  • Industrial robotic arms
  • Humanoid robot models
  • Quadruped robot models

The humanoid and quadruped models currently provide visual representations, with advanced locomotion physics planned for future development.

7. Physics-Based Quadcopter Flight

RoboForge includes a quadcopter simulation in which flight is generated through four independently controlled rotors.

Rather than animating the drone's movement, the system calculates thrust and attitude dynamics using physical forces.

This allows users to experiment with takeoff, hovering, attitude stabilization, and flight control.

8. Robot Robustness Testing

Training a robot in one environment does not guarantee that it will perform reliably under different conditions.

RoboForge addresses this with a robustness evaluation system that tests trained policies under variations in:

  • Surface friction
  • Robot mass
  • Gravitational acceleration
  • Sensor noise

The resulting scorecard helps users evaluate how reliably a trained policy performs when simulation conditions change.

9. ROS 2 and ONNX Deployment

RoboForge extends beyond simulation by supporting the export of trained policies in ONNX format, along with a ready-to-use ROS 2 node.

The generated ROS 2 integration uses standard robotics topics, including /scan, /odom, and /cmd_vel.

A built-in rosbridge server further supports communication with ROS-based systems.

This provides a pathway from simulated training to real-world robot integration, although physical deployment still requires hardware-specific validation and testing.

10. User Accounts and Credit-Based Access

RoboForge includes Google authentication and a credit-based subscription system integrated with PayPal.

Payment workflows currently use PayPal's sandbox environment, allowing subscription and billing functionality to be tested without processing live transactions.

How We Built It

RoboForge combines modern web technologies, robotics simulation, artificial intelligence, and reinforcement learning.

Frontend Architecture

The frontend is developed using React 19, TypeScript, Vite, and Three.js.

Three.js powers the interactive 3D viewport, enabling users to inspect robots, manipulate objects, visualize sensor data, and monitor simulated environments directly in the browser.

Backend and Real-Time Communication

The backend is built using FastAPI, with REST endpoints and WebSocket communication.

WebSockets stream simulation states and robot telemetry to the frontend, allowing the 3D visualization to remain synchronized with the physics engine.

MuJoCo Physics Integration

MuJoCo serves as the central physics engine.

A model compiler converts robot definitions into MuJoCo-compatible MJCF models, allowing robot structures and actuators to be simulated within a consistent physics environment.

Reinforcement Learning Pipeline

We implemented reinforcement learning using Stable-Baselines3 PPO.

Parallel training environments operate within a shared process, making it possible to visualize the actual state of each learner.

PPO optimizes a clipped surrogate objective:

[ L^{CLIP}(\theta)=\hat{\mathbb{E}}_t\left[ \min\left( r_t(\theta)\hat{A}_t, \operatorname{clip}(r_t(\theta),1-\epsilon,1+\epsilon)\hat{A}_t \right)\right] ]

This helps stabilize policy updates during training.

Robot Kinematics

For inverse kinematics, we implemented a damped least-squares Jacobian solver with joint-limit avoidance.

The core update is:

[ \Delta q=J^\top(JJ^\top+\lambda^2I)^{-1}e ]

This approach helps calculate joint adjustments while improving numerical stability near singular configurations.

Quadcopter Dynamics

Each of the four rotors generates an independent thrust force (T_i).

For hovering, total thrust must balance gravitational force:

[ \sum_{i=1}^{4}T_i=mg ]

A rotor mixer converts controller-generated thrust and torque requests into individual rotor commands.

We combined an inner attitude-control loop with a slower outer control loop to achieve stable flight behavior.

Robustness Evaluation

Our evaluation system modifies physical and sensing parameters around a baseline configuration.

For multiplicatively perturbed parameters:

[ \theta'=\theta_0(1+\delta) ]

Here, (\delta) represents a sampled perturbation.

Repeated trials help estimate policy performance under varying environmental conditions.

AI Agent Architecture

RoboForge's AI layer provides access to approximately 50 tools for robot control, scene manipulation, mission planning, and simulation management.

Instead of allowing the AI to modify the simulation arbitrarily, every requested action passes through tool-specific validation.

We also implemented a multi-level fallback system:

Cloud AI model → Local AI model → Deterministic command engine

If a cloud provider becomes unavailable or reaches its usage limits, RoboForge can continue supporting compatible commands through alternative execution paths.

The interface identifies the model or execution method that actually handled the request, providing greater transparency to users.

Challenges We Ran Into

Building RoboForge required solving problems across physics simulation, AI orchestration, reinforcement learning, real-time rendering, and system reliability.

Making Reinforcement Learning Visualization Authentic

Initially, our training ghosts were visual copies rather than representations of actual learning environments.

Although they looked convincing, they did not accurately reflect the training process.

We redesigned the training architecture so that every ghost corresponds to a real parallel learner.

This made the visualization both technically meaningful and trustworthy.

Achieving Stable Quadcopter Flight

Our first quadcopter controller could not produce reliable lift and stable flight.

We investigated rotor forces, controller behavior, and attitude stabilization.

By implementing a faster inner attitude loop, a slower outer loop, and heading stabilization, we achieved controlled flight using independent rotor thrust.

Working Around Free-Tier AI Limitations

Cloud AI providers introduced rate limits and availability constraints, which sometimes interrupted commands during development.

Instead of depending on a single provider, we developed a fallback architecture that can switch between cloud models, local models, and deterministic actions.

This made the platform more resilient and reduced dependence on paid services.

Debugging Real-Time Simulation Issues

Several issues appeared only during actual browser interaction.

For example, clearing a scene initially failed to remove drones, an incompatible Three.js controls package disrupted object manipulation, and disconnected WebSocket clients could affect backend responsiveness.

Resolving these problems required testing complete user workflows rather than relying exclusively on isolated code tests.

Coordinating Parallel Development

Our team worked on the simulation engine, robot models, and interface improvements simultaneously.

At one point, overlapping interface redesigns required us to integrate existing robot functionality into a new visual design.

We learned the importance of modular architecture, clear component boundaries, and continuous integration between team members.

Accomplishments That We're Proud Of

Our biggest accomplishment is building a unified robotics workflow that connects multiple traditionally separate engineering tools.

1. A complete robotics development pipeline

Users can design, simulate, command, train, evaluate, and export robots within one browser-based environment.

2. Real reinforcement learning visualization

Our ghost robots represent actual parallel learning environments rather than scripted animations.

3. Physics-based drone control

We achieved quadcopter flight through independent rotor forces and feedback control.

4. Natural-language robotics interaction

We connected AI reasoning with validated simulation tools, enabling complex robot actions through simple instructions.

5. Transparent and resilient AI execution

Our fallback architecture reduces dependency on any single AI provider and reports which execution method handled each command.

6. A unified family of robot models

We developed a consistent visual design for rovers, drones, robotic arms, humanoids, and quadrupeds.

RoboForge Robot Lineup

What We Learned

Developing RoboForge taught us lessons that go beyond implementing individual features.

Realistic simulation requires more than realistic visuals. A robot may look convincing, but its behavior must be grounded in actual physical calculations to provide meaningful engineering value.

AI needs validation, not unlimited control. Connecting language models to structured tools and simulator-level checks produces more predictable and reliable robot actions.

Resilience matters as much as intelligence. AI services can fail, rate limits can be reached, and network connections can disconnect. Building fallback mechanisms is essential for a dependable platform.

Transparency builds trust. Showing actual training environments, reporting the model used, and distinguishing implemented capabilities from planned features makes the platform more credible.

End-to-end testing is essential. Many of our most important bugs were discovered by interacting with the real rendered application rather than examining individual components in isolation.

Most importantly, we learned that advanced robotics workflows can be made significantly more approachable when complex technologies are integrated behind a clear and intuitive interface.

What's Next for RoboForge

RoboForge is designed as a foundation for a broader robotics development ecosystem.

Our next development priorities include:

1. Photo-to-Simulation Using Real2Sim

Our most ambitious planned feature is transforming photographs of real environments into interactive robotics simulation scenes.

A user could photograph a warehouse, classroom, laboratory, or manufacturing workspace and use that image to help generate a corresponding simulation environment.

The goal is to reduce manual 3D scene creation and make it easier to test robots against environments resembling real-world deployment locations.

2. Gemini and Google Cloud Integration

We plan to expand our AI capabilities using Gemini for reasoning and visual understanding.

We also aim to introduce isolated cloud simulation workers, allowing users to access computationally demanding robotics workflows without requiring powerful local hardware.

3. Advanced Humanoid and Quadruped Locomotion

Our current humanoid and quadruped models are visual representations.

Future development will introduce articulated dynamics, balance controllers, locomotion planning, and reinforcement-learning-based gait optimization.

4. Voice-Controlled Robotics

We want users to interact with robots through spoken commands, making robotics control more natural and accessible.

5. Public Deployment and Production Billing

We plan to expand public access to RoboForge, improve simulation scalability, and move from PayPal sandbox testing to production payment processing after completing the required validation and security work.

6. Bridging Simulation and Real-World Robotics

Our long-term objective is to strengthen the simulation-to-reality workflow through better environment reconstruction, sensor modeling, domain randomization, hardware integration, and deployment validation.

Our Vision

Robotics should not be limited to people who can afford expensive hardware, specialized software, or high-performance computers.

We envision a future where a student can learn robotics from a browser, a startup can prototype autonomous systems before purchasing hardware, and a small factory can explore automation without making a large upfront investment.

RoboForge is our step toward that future.

One browser. One instruction. Endless possibilities for robotics.

RoboForge — Design. Simulate. Train. Deploy.

Website: https://roboforge.duckdns.org

Built With

Share this project:

Updates

Submission history