Arctos Studio Pro Documentation
Powerful robot simulation, programming, and control software for the Arctos robot arm.
This documentation covers all features of Arctos Studio Pro v2.7. Start with the Quick Start Guide to get up and running quickly.
Free vs Pro Version
The free version of Arctos Studio includes all basic features needed to control your robot and create programs. Perfect for learning, prototyping, and basic automation tasks. No time limits, no feature expiration.
Free Version Includes:
- Full robot control (Open Loop and Closed Loop)
- Joint sliders and IK movement controls
- IK buttons for directional movement
- Keyboard arrow control
- Program recording and playback (MoveJ, MoveL, MoveC)
- STL model import and manipulation
- Basic collision checking (visual feedback)
- Joystick/gamepad control
- Python scripting panel
- Save/Load scenes and programs
- Webcam integration with OpenCV
- Basic color and shape detection
- Conveyor belt simulation
- PLC visual programming
Pro Version Adds:
Upgrade to Pro to unlock advanced automation, AI, and industrial features:
Real-time synchronization between simulation and physical Closed Loop robot.
Active collision blocking that stops movements before impact.
Natural language robot control with Gemini vision AI.
ChatGPT, Claude, Gemini, or local LLMs like Qwen3.
Kinect v1 and Intel RealSense point cloud support.
SVG paths, welding, 3D printing, circles, and splines.
Create boxes, cylinders, text, lines, splines, and circles.
Export to FANUC, KUKA, ABB, Universal Robots, G-code.
Automated print farm workflows with MQTT.
Reinforcement learning environment for robot training.
AI-powered multi-object detection and tracking.
Realistic gravity and object interactions.
What’s New in v2.7
Control your robot with natural language commands. The VLM system uses image analysis to detect and manipulate objects.
Support for Kinect v1 SDK and Intel RealSense cameras for 3D point cloud generation and object detection.
Integrated collision detection prevents the robot from hitting objects in the scene with configurable safety margins.
Real-time synchronization between physical and virtual robots with comprehensive scene state management.
World, Tool, and custom coordinate frames with parent-child relationships and robot-attached frames.
Interactive joystick visualizer with real-time button feedback, analog stick display, and button combinations.
Key Features
Simulate and control multiple robots in the same environment with independent programming.
Integrate conveyor belts and use the built-in PLC for complex automation systems.
Slice 3D models and generate toolpaths, or follow paths from SVG files.
Write and execute Python scripts for ultimate control and flexibility.
System Requirements
| Component | Minimum | Recommended |
|---|---|---|
| Operating System | Windows 10 | Windows 10/11 |
| Processor | Intel Core i5 | Intel Core i7 |
| Memory (RAM) | 8 GB | 16 GB |
| Graphics | OpenGL 4.0 | Dedicated GPU |
| Disk Space | 1 GB | 2 GB |
Community & Support
Installation
Download and install Arctos Studio Pro on your system.

Download
Download the latest version of Arctos Studio Pro from the official website:
Installation Steps
Double-click the downloaded installer file and follow the on-screen instructions.
We recommend installing for all users (requires admin privileges). This enables seamless automatic updates and ensures all features work correctly. Some features like hardware drivers and system integration require administrator privileges.
Select the installation directory. The default location is recommended for most users.
Wait for the installation to complete. A desktop shortcut will be created automatically.
Launch Arctos Studio Pro from the Start Menu or desktop shortcut. To unlock Pro features, log in with your Arctos Robotics account.
Some features require administrator privileges: USB driver installation, Kinect SDK integration, and certain hardware communication features. If you experience issues, try running as Administrator.
First Run and Logging In
Upon launching Arctos Studio Pro for the first time, you will be greeted with the main interface. Many of the advanced “Pro” features require you to be logged into your Arctos Robotics account.

How to Log In
- From the Settings tab in the ribbon menu, click on the Account icon to open the Account panel
- Enter your username and password
- Click the “Login” button
Once you are logged in, all the Pro features will be unlocked and available for you to use.
Create an account at arctosrobotics.com to access Pro features. The free version works without an account.
Automatic Updates
Arctos Studio Pro includes an automatic update system that checks for new versions on startup. When an update is available, you’ll be prompted to download and install it.
Keep your software up to date to get the latest features, bug fixes, and performance improvements.
Interface Overview
Learn the main components of the Arctos Studio Pro interface.

The Ribbon Menu
The Ribbon Menu at the top provides access to all tools and features, organized into 8 tabs:

| Tab | Purpose | Key Features |
|---|---|---|
| File | Scene & project management | New/Open/Save Scene, Import STL/SVG, Library, Import Robot/Gripper, Plugins |
| Connections | Robot hardware communication | Open Loop/Closed Loop selection, Port selection, Connect/Disconnect, Digital Twin |
| Program | Robot programming | Record/Update Target, MoveJ/MoveL/MoveC, Run/Stop Program, Pick/Place, Post Process |
| Modify | Object manipulation | Move/Rotate/Scale, Color STL, Collision Check/Prevention, Physics, Show Path |
| Trajectory | Path generation | Follow SVG/Lines/Circles, 3D Print, Slice Model, Welding paths |
| Modeling | Create objects | Create Box/Cylinder/Polygon, Draw Lines/Splines/Circles, Create Text, Measure |
| Robot | Advanced features | Conveyor, Sensors, Camera, Depth Camera, PLC, Joystick, VLM, Gym, Bambu Lab |
| Settings | Configuration | Robot Config, Calibration, Homing, AI Settings, GRBL/MKS Settings, Dark Mode, Account |
The 3D Viewer
The central 3D Viewer shows real-time simulation of your robot and environment. Navigate using your mouse:

| Action | Mouse Control | Description |
|---|---|---|
| Orbit | Left-click + drag | Rotate the camera around the scene |
| Pan | Right-click + drag | Move the view left/right/up/down |
| Zoom | Mouse wheel | Zoom in and out |
| Select | Left-click on object | Select objects to show manipulation gizmo |
| Gizmo Mode | Press G | Toggle between translate and rotate gizmo |
Dockable Panels
Arctos Studio Pro uses a flexible panel system. Panels can be pinned to keep them always visible, toggled via ribbon buttons, or stacked with tabs.
| Panel | Description | Access |
|---|---|---|
| Program Tree | Manage sequences, targets, and models | Always visible (right side) |
| Joint Control | Direct joint angle control with sliders | Always visible (left side) |
| IK Control | End-effector position/rotation control | Always visible (left side) |
| Camera Panel | Webcam feed and computer vision | Robot tab → Camera |
| Depth Camera | Kinect/RealSense point cloud | Robot tab → Depth Camera |
| Conveyor Belt | Conveyor control and settings | Robot tab → Conveyor |
| PLC Panel | Visual logic programming | Robot tab → PLC |
| Python Panel | Script editor and execution | Robot tab → Python Program |
| VLM Panel | Vision Language Model control | Robot tab → VLM Control |
| Gripper Panel | Gripper offset configuration | File tab → Gripper Settings |
| Coordinate Frames | World/Tool/Custom frames | Program tab → Coordinate Frames |
Program Tree

The Program Tree on the right side organizes your project:
- Targets: Recorded robot positions (drag to reorder)
- Models: Imported STL files (right-click for options)
- SVGs: Imported vector paths
- Drawings: Lines, splines, circles you’ve created
Right-click any item in the Program Tree for context menu options like rename, delete, duplicate, or properties.
Quick Start Guide
Get up and running with Arctos Studio Pro in minutes.
First Steps
Start the application from the desktop shortcut or Start Menu. The optimized loading screen shows initialization progress.
Go to Robot tab → Select your robot version (Open Loop or Closed Loop) → Choose the COM port → Click Connect.
Use the Joint Control panel to move individual joints, or the IK Control panel to move the end-effector in Cartesian space.
Move the robot to desired positions and click Record Target to save each position. Build a sequence of movements.
Click Run Program or press R to execute your sequence. Use Stop or S to halt at any time.
Keyboard Shortcuts
| Shortcut | Action |
|---|---|
| R | Run program |
| S | Stop program |
| G | Toggle gizmo mode (translate/rotate) |
| Ctrl+S | Save scene |
| Ctrl+O | Open scene |
| Delete | Delete selected object |
You’re now ready to explore the full capabilities of Arctos Studio Pro. Check out the other sections for detailed guides on each feature.
Robot Connection
Connect to your Arctos robot using serial or CAN bus communication.
Connecting to a Robot

- Navigate to the Connections tab in the Ribbon Menu
- Choose Robot Version: Select “Open Loop” or “Closed Loop” from the dropdown
- Select Port: Choose the correct communication port for your robot
- Click Connect: The status indicator will turn green when successful
Multi-Robot Environments
Arctos Studio Pro allows you to work with multiple robots in the same scene.

Robot Versions
Closed Loop Connection
The closed loop version uses CAN bus communication via a CANable adapter for precise position feedback.
- Hardware: CANable v2 adapter, MKS Servo 42D/57D drivers
- Communication: Direct CAN two-way communication
- Features: Position feedback, encoder data, real-time status, Digital Twin support
Advantages
- ✅ Precise position feedback from encoders
- ✅ Higher torque and speed capability
- ✅ Real-time status monitoring
- ✅ Required for Digital Twin feature
Connection Steps
- Connect CANable adapter to USB port
- Select “Closed Loop” in the Connections tab
- Choose the CANable COM port from dropdown
- Click Connect – status turns green when successful
Open Loop Connection
The open loop version uses serial communication with an Arduino Mega running GRBL firmware.
- Hardware: Arduino Mega 2560, CNC Shield V3, TMC2209 drivers
- Communication: Serial/USB at 115200 baud
- Features: G-code commands, simple setup, lower cost
Advantages
- ✅ Simple setup and wiring
- ✅ Lower cost components
- ✅ Good for learning and prototyping
- ❌ No position feedback (can lose steps under load)
Connection Steps
- Connect Arduino to USB port
- Select “Open Loop” in the Connections tab
- Choose the Arduino COM port
- Click Connect
- Click “Unlock” if GRBL is in alarm state
Digital Twin Pro
Digital Twin enables real-time synchronization between the simulated robot in Arctos Studio and your physical robot. When enabled, the physical robot mirrors every movement of the simulation.
When Digital Twin is enabled, the physical robot moves immediately! Ensure the workspace is clear and you’re ready to hit emergency stop if needed.
Digital Twin is only available for Closed Loop robots using CAN bus communication. Open Loop robots do not support real-time position feedback required for Digital Twin synchronization.
How to Enable
- Connect to your Closed Loop robot first (CAN bus)
- Click the “Digital Twin” button in the Connections tab
- The button stays pressed to indicate it’s active
- Move the simulated robot → physical robot follows in real-time
- Click again to disable synchronization
Requirements
- Closed Loop (CAN) robot version – not available for Open Loop
- Active CAN bus connection
- Pro subscription
Connection Status
| Status | Color | Meaning |
|---|---|---|
| Disconnected | 🔴 Red | No connection to robot hardware |
| Connected | 🟢 Green | Successfully connected and ready |
Movement Control
Control your robot using joints, inverse kinematics, or interactive gizmos.
Arctos Studio Pro offers several ways to control your robot:
1. Joint & IK Control Panel

The Joint Control panel provides direct control over each of the robot’s 6 joints using sliders:
- Joint Sliders: Drag to move each joint independently (J1-J6)
- Input boxes: Enter precise angle values in degrees
- Home button: Return all joints to zero position
- Real-time feedback: See current joint angles update as robot moves
2. End Effector Control (IK)
For more intuitive control, you can directly manipulate the robot’s end effector (the “hand” or “tool”).

IK Sliders
Use the IK sliders to adjust end-effector position and rotation:
- X, Y, Z: Position in millimeters
- Rx, Ry, Rz: Rotation in degrees
IK Movement Buttons
Click on the translation or rotation images to move the robot in that direction:
- Single click: Incremental movement (configurable step size)
- Hold click: Continuous movement while held
- Arrow directions: Move in X+, X-, Y+, Y-, Z+, Z-
Keyboard Arrow Control
Use keyboard arrows for quick movement:
| Key | Action |
|---|---|
| ↑ / ↓ | Move in Y axis |
| ← / → | Move in X axis |
| Page Up / Page Down | Move in Z axis |
Interactive Gizmo
Click on the end-effector in the 3D view to show the manipulation gizmo:
Version 2.7 includes improved gizmo responsiveness for smoother, more precise manipulation.
Joystick/Gamepad Control
Connect a gamepad for intuitive real-time control. See the Joystick Control section for setup details.
Joystick Control
Control your robot with a gamepad for intuitive, real-time manipulation.
The joystick system has been completely redesigned with an interactive visualizer and button combination support.
Setup
- Connect a compatible gamepad (PlayStation, Xbox, or generic USB controller)
- Go to Robot tab → Click Joystick button
- Select your controller from the dropdown
- Enable joystick control
Interactive Visualizer
The joystick visualizer shows real-time feedback of all inputs:
- Button highlights: Visual feedback when buttons are pressed
- Analog sticks: Real-time position display
- D-Pad: Direction indicators
- Triggers: Analog trigger values
Axis Mapping
| Joystick Input | Default Mapping |
|---|---|
| Left Stick X | Robot X translation |
| Left Stick Y | Robot Y translation |
| Right Stick Y | Robot Z translation |
| Triggers | Gripper open/close |
| D-Pad | Joint selection/movement |
Button Combinations
Create button combinations for advanced actions. Hold multiple buttons simultaneously to trigger special functions like recording targets or running programs.
Robot Programming
Create and execute robot programs using targets and sequences.

Recording Targets
A target stores the robot’s complete state: joint positions, gripper state, and movement parameters. This is the basic building block of robot programming.
Targets respect the currently active coordinate frame. If you have a custom frame selected, targets will be recorded relative to that frame. Switch to World frame for absolute positioning.
- Move the robot to the desired position using Joint sliders, IK controls, or the gizmo
- Set the gripper state (open/closed) if needed
- Click Record Target in the Program tab (or press T)
- The target appears in the Program Tree on the right
- Repeat for each position in your program
Movement Types
The movement type determines HOW the robot moves between targets. Choose the right type for your application:
MoveJ – Joint Interpolation
The robot interpolates each joint independently to reach the target. The end-effector follows a curved, non-linear path.
- ✅ Fastest movement between points
- ✅ Most efficient for the motors
- ✅ Best for point-to-point moves where path doesn’t matter
- ❌ Path is unpredictable (curved)
Use for: Moving between work areas, approach/retreat moves, any move where the path doesn’t matter.
MoveL – Linear Interpolation
The robot moves the end-effector in a straight line from the current position to the target.
- ✅ Predictable straight-line path
- ✅ Essential for welding, dispensing, cutting
- ✅ Consistent speed along path
- ❌ Slower than MoveJ
Use for: Welding seams, dispensing adhesive, cutting operations, any operation requiring a straight path.
MoveC – Circular Interpolation
The robot moves the end-effector along a circular arc. Requires three points: start, via (middle), and end.
- ✅ Smooth curved paths
- ✅ Perfect for circular features
- ✅ Maintains orientation along arc
- ❌ Requires careful via-point placement
How to use: Record start point with MoveC → Record via point (middle of arc) with MoveC → Record end point with MoveC.
Wait Commands
Add pauses to your program for gripper operations, curing time, or synchronization:
- Click Add Wait in the Program tab
- Choose wait type: Time Delay (seconds) or Wait for IO (sensor input)
- Configure the wait condition
- Click Add – the wait command appears in Program Tree
Python in Programs Pro
Embed Python code directly in your robot programs for complex logic, calculations, and external system integration.
- Click Add Python in the Program tab
- Write your Python code in the dialog
- Click Add – the Python block appears in Program Tree
- Code executes when the program reaches this point
Post Process Pro
Export your program to robot-specific formats for industrial robots:
| Robot Brand | Output Format |
|---|---|
| FANUC | .LS files |
| KUKA | .SRC files |
| ABB | RAPID code |
| Universal Robots | .script files |
| CNC/3D Printing | G-code |
Editing Programs

- Reorder: Drag targets in the tree to change execution order
- Update: Select a target, move robot, click “Update Target”
- Delete: Right-click → Delete or press Delete
- Rename: Double-click to rename
Direct Control vs. Simulation

Arctos Studio Pro can operate in two modes:
- Simulation: Robot movements are simulated in software only – safe for testing
- Direct Control (Digital Twin): Commands are sent to the physical robot in real-time
Running Programs
- Run Program: Click button or press R – executes on selected robot
- Run All Robots: Executes programs on ALL robots simultaneously
- Stop: Click button or press S – immediately halts execution
The physical robot will move! Ensure workspace is clear before running programs.
Custom Grippers
Load and configure custom gripper models for your robot.
Loading Grippers
Arctos Studio Pro supports custom gripper models in STL and URDF formats:
- STL: Static gripper meshes
- URDF: Articulated grippers with movable joints
From Library
Browse the built-in gripper library in Robot tab → Gripper Library. Click to load a gripper.
Custom Import
Import your own gripper models via File → Import Gripper.
Gripper Offsets
Configure the gripper’s position and rotation offset from the robot’s tool frame:
- Position offset: X, Y, Z translation in millimeters
- Rotation offset: Rx, Ry, Rz rotation in degrees
Gripper Commands
Closed Loop Gripper Control
Closed loop grippers use CAN bus commands for precise servo control:
The gripper position is sent via CAN message to the gripper servo driver (typically CAN ID 7).
Open Loop Gripper Control
Open loop grippers use G-code M97 commands with position and time parameters:
Parameters:
- B: Position (0-100, where 0=open, 100=closed)
- T: Time in seconds for the movement
Coordinate Frames
Manage World, Tool, and custom coordinate frames for precise positioning.
The coordinate frame system has been completely redesigned with support for parent-child relationships and robot-attached frames.
Frame Types
World Frame
The global reference frame. All positions are ultimately relative to this frame.
Tool Frame
Attached to the robot’s end-effector. Moves with the robot and represents the tool center point (TCP). Can be used as a “7th axis” for extended reach.
Custom Frames
User-defined frames for workpieces, fixtures, or reference points. Can be:
- Static: Fixed in world space
- Robot-attached: Moves with the robot end-effector
- Parented: Relative to another frame
Frames Panel
Access the Coordinate Frames panel from Robot tab → Frames:
- Frame list: View all frames with visibility toggles
- Position/Rotation: Edit frame transform values
- Add/Delete: Create or remove custom frames
Tool Frame Configuration
Configure the tool frame offset to match your gripper or tool:
- Select the Tool frame in the Frames panel
- Adjust position offset (X, Y, Z in mm)
- Adjust rotation offset (Rx, Ry, Rz in degrees)
- The trajectory will now follow the tool tip instead of the flange
Trajectories now follow the active tool frame instead of using a fixed downward orientation.
Real-time Collision Avoidance
Prevent your robot from colliding with objects in the scene.
Real-time collision prevention requires an Arctos Studio Pro subscription. Collision Check (visual only) is available in the free version.
Collision Check vs Prevention
| Feature | Collision Check | Collision Prevention Pro |
|---|---|---|
| Function | Visual feedback only | Actively blocks movements |
| Indication | Colliding parts turn red | Movement is stopped/reverted |
| Use case | Path verification | Safe operation during teaching |
How It Works
The collision avoidance system continuously monitors the robot’s position and planned movements:
- Bounding box detection: Checks robot links against object bounds
- Safety margins: Configurable clearance around objects (default 30mm)
- Self-collision: Prevents robot from hitting itself
- Path planning: RRT-based planning for collision-free paths
Enabling Collision Features
Collision Check (Visual)
- Go to Modify tab
- Click Collision Check toggle
- Move the robot – colliding parts highlight in red
Collision Prevention (Active) Pro
- Go to Modify tab
- Click Collision Prevention toggle
- The system now blocks movements that would cause collisions
- Robot reverts to last safe position if collision detected
Kinect Integration Pro
When both Depth Camera and Collision Prevention are enabled, the robot will avoid real-world objects detected by the Kinect or RealSense camera:
- Connect and enable Depth Camera (Robot tab → Depth Camera)
- Enable Collision Prevention (Modify tab)
- Point cloud data is used for collision detection
- Robot avoids both virtual objects AND real-world obstacles
Settings
| Setting | Default | Description |
|---|---|---|
| Safety Margin | 30mm | Minimum clearance from objects |
| Approach Height | 150mm | Height above objects for approach |
| Retreat Height | 200mm | Height for safe retreat movements |
Collision avoidance is a software safety aid, not a guarantee. Always supervise robot operation and maintain safe distances. Use physical E-stop for emergencies.
Vision & Depth Sensing
Use cameras and depth sensors for object detection and 3D perception.
Camera Panel (OpenCV)
Access the Camera Panel from Robot tab → Camera:
- Select camera from dropdown (Simulated or Real Camera 0, 1, etc.)
- Click “Connect” to start the feed
- Enable detection features as needed

OpenCV Detection Modes
| Mode | Description | Use Case |
|---|---|---|
| Color Detection | Filter by red, green, blue, yellow, etc. | Sorting by color |
| Shape Detection | Detect boxes, circles, triangles | Part identification |
| Contour Detection | Find object outlines | Edge-based picking |
Camera Calibration
For accurate robot-camera coordination:
- Use QR code calibration for automatic alignment
- Or manually set camera-to-robot transform
- Calibration data is saved with the scene
YOLO Object Detection Pro
YOLO AI detection requires an Arctos Studio Pro subscription.
YOLO (You Only Look Once) provides AI-powered multi-object detection:
- Real-time detection: Identify multiple objects simultaneously
- 80+ object classes: Detect common objects out of the box
- Bounding boxes: Get precise object locations
- Confidence scores: Filter by detection certainty
Enabling YOLO
- Open Camera panel
- Enable “YOLO Detection” toggle
- Objects are detected and labeled in real-time
- Use detected positions for robot pick operations
Sensors
Access from Robot tab → Sensors:
Add virtual sensors to your scene for automation logic:
- Proximity sensors: Detect object presence within range
- Color sensors: Detect specific object colors
- Position sensors: Track object positions
Sensors integrate with the PLC panel for automation logic.
Depth Camera Setup Pro
Depth camera integration requires an Arctos Studio Pro subscription.
Access from Robot tab → Depth Camera:
Kinect v1 Setup
- Backend options: Kinect SDK (Windows) or freenect (cross-platform)
- Resolution: 640×480 depth
- Features: Point cloud generation, RGB + Depth alignment
Connection Steps
- Install Kinect SDK 1.8 from Microsoft (Windows) or freenect drivers
- Connect Kinect to USB port (requires USB 2.0+ and external power)
- Open Depth Camera panel
- Select “Kinect SDK” or “Freenect” backend
- Click Connect
Intel RealSense Setup
- Supported models: D400 series (D415, D435, D455)
- Resolution: Up to 1280×720 depth
- Features: High-quality point clouds, built-in IMU
Connection Steps
- Install Intel RealSense SDK 2.0
- Connect camera to USB 3.0 port
- Open Depth Camera panel
- Select “RealSense” backend
- Click Connect
Point Cloud Options
Configure point cloud visualization in the Depth Camera panel:
- Color mode: RGB color from camera or thermal visualization
- Downsampling: Reduce point count for better performance
- Collision detection: Enable to use point cloud for collision avoidance
- Update rate: How often the point cloud refreshes
Use downsampling to reduce point count if the 3D viewer becomes slow. Start with 4x downsampling and adjust as needed.
Vision Language Model (VLM)
Control your robot with natural language commands using vision AI.
VLM control requires an Arctos Studio Pro subscription and Gemini API access.
What is VLM?
Vision Language Models combine image understanding with natural language processing. Give commands like:
- “Pick up the red ball”
- “Move the blue box to the left”
- “Stack the cylinders”
- “Sort the objects by color”
The VLM analyzes the camera image, identifies the target object, and generates robot commands automatically.
Setup Requirements
- Gemini API Key: Go to Settings tab → AI Settings → Enter your Gemini API key
- Camera: Connect a camera via Robot tab → Camera
- Depth Camera (recommended): For accurate 3D positioning
Using the VLM Panel
Access from Robot tab → VLM Control:
- Ensure camera is connected and showing live feed
- Type your command in the input field
- Press Enter or click “Execute”
- Watch the execution status as VLM processes
How It Works
Camera captures the current scene image showing all objects in the workspace.
Gemini API analyzes the image along with your natural language command to identify the target object and understand the requested action.
Object location is identified in pixel coordinates, then depth camera provides the 3D position in robot coordinates.
Robot executes the pick/place operation, moving to the calculated position and performing the requested action.
Tips for Best Results
- Good lighting: Ensure objects are well-lit and clearly visible
- Distinctive objects: Use objects with clear colors and shapes
- Specific commands: Be clear about which object and what action
- Camera angle: Position camera to see all objects clearly
“Pick up the red cube and place it on the blue platform” • “Move all green objects to the right side” • “Stack the cylinders from largest to smallest”
AI & LLM Integration
Use AI assistants and language models for intelligent robot control.
AI features require an Arctos Studio Pro subscription.
Supported AI Providers
Arctos Studio supports multiple AI providers for different use cases:
| Provider | Best For | Setup |
|---|---|---|
| Google Gemini | VLM control, vision tasks | API key in Settings → AI Settings |
| OpenAI ChatGPT | Code generation, explanations | API key in Settings → AI Settings |
| Anthropic Claude | Complex reasoning, safety | API key in Settings → AI Settings |
| Local LLMs | Offline operation, privacy | Ollama or model path |
AI Assistant
The built-in AI assistant can help you with:
- Generating Python code for robot control
- Explaining robot concepts and parameters
- Troubleshooting issues
- Creating complex movement sequences
- Optimizing robot programs
Local LLM Support
Run AI models locally without internet connection for privacy and offline operation:
Supported Backends
- Ollama: Easy-to-use local model server (recommended)
- Transformers + PEFT: Direct Python inference with fine-tuned adapters
- Gradio: Connect to Gradio-hosted models
Recommended Local Models
For local LLM usage, the community recommends Qwen3 480B for best results with robot control tasks. Smaller models like Qwen3 7B or Llama 3 8B also work well for basic tasks.
Model Configuration
Configure local models in Settings → AI Settings:
- Model path or Hugging Face repository
- Adapter path for fine-tuned models
- Quantization settings (4-bit for GPU, float32 for CPU)
- Ollama server URL (default: localhost:11434)
Reinforcement Learning (Gym)
Train your robot using reinforcement learning in the Gym panel:
- Environment setup: Define observation and action spaces
- Reward function: Configure success/failure criteria
- Training: Run PPO or other RL algorithms
- Deployment: Load trained models for execution
Training Process

The training process involves:
- Setting up the training environment with objects and obstacles
- Defining what constitutes success (positive rewards) and failure (negative rewards)
- Running the training algorithm (PPO recommended)
- Monitoring training progress and adjusting parameters
- Deploying the trained model for execution
Access from Robot tab → Gym.
Conveyor Belts
Add conveyor belts to your automation setup for realistic factory simulation.
Adding a Conveyor
- Go to Robot tab
- Click Conveyor Belt button
- A conveyor belt is added to the scene
- Use the gizmo to position it in your workspace
Conveyor Panel Controls
| Control | Function |
|---|---|
| Start/Stop | Control belt movement |
| Speed Slider | Adjust belt speed (mm/s) |
| Direction | Forward or reverse movement |
| Show Bounds | Toggle boundary visualization |
Physics Integration Pro
When physics simulation is enabled (Modify tab → Gravity), objects interact realistically with the conveyor:
- Objects placed on the belt move with it automatically
- Objects fall onto the belt due to gravity
- Robot can pick objects from the moving belt
- Objects collide with each other on the belt
Multiple Conveyors
You can add multiple conveyor belts to create complex automation scenarios:
- Each conveyor has independent speed and direction controls
- Position conveyors to create transfer stations
- Combine with sensors for automated sorting
Example Workflow: Pick from Moving Conveyor
- Add and position a conveyor belt
- Enable physics (Modify tab → Gravity)
- Place objects on the conveyor
- Start the conveyor
- Program the robot to pick objects as they pass
- Use sensors to trigger pick operations
Combine conveyors with PLC logic and sensors to create fully automated sorting and assembly line simulations.
PLC & Sensors
Create automation logic with the visual PLC editor and sensors.

Visual PLC Editor
Access from Robot tab → PLC. The PLC panel provides a visual canvas for building automation logic without code:
Block Types
| Block Type | Function | Examples |
|---|---|---|
| Input Blocks | Read sensor values | Proximity sensor, Color sensor, Button |
| Logic Blocks | Boolean operations | AND, OR, NOT, XOR |
| Output Blocks | Control actuators | Motor, Gripper, Conveyor, LED |
| Timer Blocks | Time-based events | Delay, Pulse, One-shot |
| Counter Blocks | Count events | Up counter, Down counter |
Building Logic
- Drag blocks from the toolbox onto the canvas
- Connect blocks by dragging wires between ports
- Configure block properties (click to select)
- Run the PLC logic to test
Adding Sensors
Access from Robot tab → Sensors:
- Browse the sensor library
- Click a sensor to add it to the scene
- Position using the gizmo
- Configure detection range and trigger conditions
Sensor Types
- Proximity sensors: Detect object presence within range
- Color sensors: Detect specific object colors
- Position sensors: Track object positions
Arduino Code Generation
Export your PLC logic to run on real Arduino hardware:
To use PLC with physical Arduino hardware, you need to upload the Arduino Bridge firmware first. Download Arduino Bridge Firmware →

Supported Hardware
- Arduino Uno – Tested and recommended
- Arduino Mega – More I/O pins available
- ESP32 – WiFi capability for remote control
Setup Steps
- Download and install the firmware:
- Download the Arduino Bridge firmware
- Extract the ZIP file
- Open
arduino_bridge.inoin Arduino IDE - Select your board type (Uno/Mega/ESP32)
- Upload to your Arduino
- Design your logic in the PLC editor
- Map pins: Go to Settings tab → PLC Settings
- Assign pins: Map PLC inputs/outputs to Arduino pins
- Generate code: Click “Generate Code”
- Connect hardware: Wire physical sensors and actuators to mapped pins
- Test: Run your PLC logic with real hardware
Arduino pins are 5V (3.3V for ESP32). Use appropriate level shifters or relays for higher voltage devices. Never connect mains voltage directly to Arduino pins!
Example: Conveyor Stop on Sensor
- Add a “Proximity Sensor” input block
- Add a “NOT” logic block
- Add a “Conveyor Motor” output block
- Connect: Sensor → NOT → Motor
- Result: Conveyor stops when sensor detects an object
Use the PLC to create complex automation sequences like sorting by color, counting parts, or triggering robot programs based on sensor input.
Bambu Lab Integration
Connect to Bambu Lab 3D printers for automated robot-printer workflows.
Bambu Lab API integration enables automated print farm operations where the robot removes finished prints.
MQTT Connection Setup
Connect to your Bambu Lab printer via MQTT protocol:
- Open the Bambu Panel from Robot tab → Bambu Lab API
- Enter your printer’s IP Address (find in printer settings)
- Enter the Serial Number (on printer label)
- Enter the Access Code (from printer network settings)
- Click Connect
On your Bambu printer, go to Settings → Network → View the IP address and access code. Serial number is on the printer label.
Print Monitoring
Monitor your print status in real-time:
| Status | Description |
|---|---|
| Idle | Printer ready, no active print |
| Printing | Print in progress |
| Paused | Print paused by user or error |
| Complete | Print finished successfully |
| Failed | Print failed or cancelled |
Additional information displayed:
- Progress: Percentage complete
- Layer info: Current layer / total layers
- Time remaining: Estimated completion time
- Temperatures: Nozzle and bed temperatures
Automation Triggers
Configure robot actions based on print events:
| Trigger | Robot Action |
|---|---|
| Print Complete | Robot removes finished part from bed |
| Print Failed | Robot clears bed for retry |
| Custom | Define your own automation rules |
Print Farm Workflow Example
- Printer completes a print job
- Arctos Studio detects “Complete” status via MQTT
- Robot program triggers automatically
- Robot moves to printer, picks up the finished part
- Robot places part in collection area
- Printer bed is clear and ready for next job
- Cycle repeats for continuous production
Create a fully automated print farm where the robot handles part removal 24/7, maximizing printer utilization.
Trajectory & Path Following
Create complex robot paths from SVG files, drawings, and 3D models.
All trajectory and path following features require an Arctos Studio Pro subscription.

SVG Path Following Pro
Import SVG files and have the robot trace the paths – perfect for drawing, cutting, or engraving:
- Go to File tab → Import SVG
- Select your SVG file
- Position and scale the SVG using the gizmo
- Go to Trajectory tab → Click Follow SVG
- Targets are generated along the SVG paths
- Run the program to execute
Simple SVGs with clean paths work best. Convert text to outlines in your vector editor before importing. Complex SVGs may generate many targets.
Lines & Splines Pro
Follow paths you’ve drawn in the Modeling tab:
- Draw lines or splines using Modeling tab tools
- Go to Trajectory tab → Click Follow Lines/Splines
- Targets are generated along your drawn path
Circles Pro
Follow circular paths for round cutting or polishing operations:
- Draw a circle using Modeling tab → Create Circle
- Go to Trajectory tab → Click Follow Circles
- Targets are generated around the circle
Welding (Edge Paths) Pro
The Welding (Edge Path) feature enables you to create robot welding paths directly along the edges of imported 3D models. It automates tool positioning with precise orientation and tool compensation, ideal for welding tasks that require accuracy and consistency.
Getting Started with Welding
- Import your STL model (the workpiece to weld)
- Define the welding tool length in settings
- Click Show Edges to activate edge selection mode
- Hover over the model – edges highlight as you move
- Click an edge to select it (turns blue)
- Click Welding button to open the Edge Orientation Dialog
Edge Orientation Dialog
Configure tool angles for each segment in the Edge Orientation Dialog:
- Pitch: Torch angle forward/back (tilt toward/away from weld direction)
- Yaw: Torch angle left/right (side-to-side adjustment)
- Roll: Torch rotation around its axis
Common welding configurations like flat, vertical, and overhead welding are easily achievable with preset values. You can preview and adjust orientations in real-time.
Path Generation
After setting orientations, click “Create Path” to generate:
- Safe approach and departure points
- Intermediate points for smooth paths
- Automatic validation for robot reachability
- TCP positions with orientation offsets
Use clean STL files with well-defined edges. Measure your tool precisely. Test orientations frequently and simulate paths before live welding.
3D Printing (Slicing) Pro
Generate toolpaths from STL models for robotic 3D printing:
- Import an STL model
- Select the model
- Go to Trajectory tab → Click Slice Model
- Configure slicing parameters
- Click “Slice” to generate toolpath visualization
- Click Create Targets to generate robot program
Slicing Parameters
| Parameter | Range | Description |
|---|---|---|
| Layer Height | 0.1-0.3mm | Thickness of each layer |
| Print Speed | 10-100 mm/s | Movement speed while extruding |
| Infill | 0-100% | Interior fill percentage |
| Perimeters | 1-5 | Number of outline passes |
Complex prints can generate thousands of targets. Ensure your system can handle large programs before slicing detailed models.
Measure Tool
Measure distances between any two points in the 3D viewer.
Activating the Tool
- Go to Modeling tab
- Click Measure button
- The measure tool is now active
Using the Measure Tool
- Click on the first point (on any object, frame, or point cloud)
- Click on the second point
- The distance is displayed in a popup
Measurable Targets
- STL models: Click on model surfaces
- Coordinate frames: Click on frame origins
- Point clouds: Click on depth camera points
- Drawing objects: Click on lines, boxes, cylinders
Measurement Display
The measurement popup shows:
- Distance in millimeters
- Visual line between points
- Point markers at both locations
Press Escape or click the Measure button again to deactivate the tool.
Python Scripting
Write and execute Python scripts for advanced robot control.
Python Panel
Access the Python Panel from Robot tab → Python:
- Code editor: Write Python scripts with syntax highlighting
- Run button: Execute the current script
- Output console: View print statements and errors
- Save/Load: Save scripts for later use
Basic Commands
Working with Objects
Advanced Features
Python API Reference
Complete reference for all Python commands available in Arctos Studio.
Movement Commands
| Command | Description |
|---|---|
move_joints(values, feed_rate=1000) | Move joints to absolute angles (degrees) |
translate_ik(x, y, z) | Move end-effector to position (meters) |
rotate_ik(rx, ry, rz) | Rotate end-effector (degrees) |
move_ee_to_world_pose(x, y, z, rx, ry, rz) | Move to world position (mm) with orientation |
go_to_zero() | Move all joints to 0 degrees |
set_gripper(position) | Set gripper (0=open, 100=closed) |
open_gripper() | Fully open gripper |
close_gripper() | Fully close gripper |
with_transition(func, *args, total_steps=50) | Execute movement with smooth transition |
Program Commands
| Command | Description |
|---|---|
record_target() | Record current pose as target |
record_movej() | Record target with MoveJ type |
record_movel() | Record target with MoveL type |
record_movec() | Record target with MoveC type |
update_target() | Update selected target with current pose |
run_program(timeout=30) | Execute program and wait for completion |
run_program_no_wait() | Execute program without waiting |
run_program_multiple(count, timeout, delay) | Run program multiple times |
stop_program() | Stop running program |
stop() | Emergency stop all operations |
save_program_as(filepath) | Save program to file |
load_program_as(filepath) | Load program from file |
clear_all_targets() | Remove all targets |
add_wait(duration_ms) | Add wait delay to program |
Object Commands
| Command | Description |
|---|---|
create_box(x, y, z, w, h, d) | Create box at position with dimensions |
create_cylinder(x, y, z, r, h) | Create cylinder at position |
create_line(x1, y1, z1, x2, y2, z2) | Create line between two points |
import_stl(filepath) | Import STL model |
import_svg(filepath) | Import SVG file |
list_models() | List all models with index/name |
select_model(index_or_name) | Select model for operations |
translate_model(x, y, z) | Move selected model |
rotate_model(rx, ry, rz) | Rotate selected model |
scale_model(sx, sy, sz) | Scale selected model |
color_model(color_name) | Change model color (red, green, blue, etc.) |
delete_model(index_or_name) | Delete a model |
clear_models() | Delete all models |
get_model_bounds(index_or_name) | Get model bounding box |
get_stl_model_details(index_or_name) | Get detailed model info |
State Commands
| Command | Description |
|---|---|
get_joint_values() | Get current joint angles |
get_translation() | Get end-effector position |
get_rotation() | Get end-effector rotation |
get_end_effector_pose() | Get full EE pose matrix |
get_current_pose() | Get current pose in active frame |
is_robot_program_running() | Check if program is executing |
Collision Commands
| Command | Description |
|---|---|
enable_collision_prevention() | Enable collision blocking |
disable_collision_prevention() | Disable collision blocking |
get_collision_stats() | Get collision prevention statistics |
check_path_collision(start, end) | Check if path causes collision |
plan_safe_path(start, end) | Plan collision-free path |
Multi-Robot Commands
| Command | Description |
|---|---|
add_robot(x, y, z, rotation) | Add duplicate robot at position |
select_robot(index) | Select robot by index (0=main) |
clear_duplicate_robots() | Remove all duplicate robots |
list_available_robots() | List robots in library |
import_robot(name, x, y, rotation) | Import robot from library |
Conveyor Commands
| Command | Description |
|---|---|
set_conveyor_power(enabled) | Start/stop conveyor |
set_conveyor_speed(speed) | Set conveyor speed (mm/s) |
add_conveyor_belt() | Add conveyor to scene |
Camera Commands
| Command | Description |
|---|---|
list_available_cameras() | List connected cameras |
select_camera(index) | Select camera by index |
start_real_camera() | Start camera feed |
stop_real_camera() | Stop camera feed |
toggle_cv(enable) | Enable/disable computer vision |
set_cv_color(color_name) | Set color detection filter |
get_detected_object() | Get detected object info |
Bambu Lab Commands
| Command | Description |
|---|---|
connect_bambu(ip, serial, access_code) | Connect to Bambu printer |
disconnect_bambu() | Disconnect from printer |
get_bambu_status() | Get printer status |
is_bambu_printing() | Check if printing |
wait_for_bambu_print_complete(timeout) | Wait for print to finish |
get_bambu_print_progress() | Get print progress (0-100) |
Pick & Place Commands
| Command | Description |
|---|---|
pick_object() | Pick selected object |
place_object() | Place held object |
find_object_by_keyword(keyword) | Find object by name/color |
get_object_by_color_and_type(color, type) | Find object by color and type |
File Operations
Manage scenes, import models, and organize your projects.

Scene Management
| Action | Description | Shortcut |
|---|---|---|
| New Scene | Create fresh, empty workspace | – |
| Open Scene | Load a saved .arctos file | Ctrl+O |
| Save Scene As | Save workspace to .arctos file | Ctrl+S |
Creating a new scene clears everything. This cannot be undone – always save your work first!
Importing Models
STL Models
Import 3D models for workpieces, fixtures, or obstacles:
- Click Import Model in File tab
- Select your .stl file
- Model appears at origin (0, 0, 0)
- Use gizmo or Modify tools to position
SVG Files
Import 2D vector graphics for path following:
- Click Import SVG in File tab
- Select your .svg file
- SVG appears on ground plane
- Use Trajectory tab → Follow SVG to generate robot path
Library

Access pre-configured robots, grippers, and sample scenes:
- Robots: Different robot arm configurations
- Grippers: Various end-effector options
- Models: Sample workpieces and fixtures
- Scenes: Complete example projects
Gripper Settings
Configure gripper position and rotation offset from the robot flange:
- Position Offset (X, Y, Z): Adjust in millimeters
- Rotation Offset (Rx, Ry, Rz): Adjust in degrees
Plugins

Extend Arctos Studio functionality with community and custom plugins:
- Click Plugins in File tab
- Browse installed and available plugins
- Toggle plugins on/off with checkboxes
- Some plugins may require restart
Community Plugins
Find and download community plugins from the official repository:
Arctos Studio Plugins Repository
Installing Plugins
- Download the plugin .py file from the repository
- Place it in the
pluginsfolder in your Arctos Studio installation - Restart Arctos Studio
- Enable the plugin in File tab → Plugins
Want to create your own plugin? Check the plugins repository for examples and documentation on the plugin API.
Modify & Transform
Manipulate objects in your scene with precision tools.
Modifying Objects (The “Modify” Tools)
Once an object is in the scene, you can modify it using interactive controls or the tools in the Modify tab:

Transform Tools
| Tool | Function | Access |
|---|---|---|
| Move | Translate object by X, Y, Z values | Modify tab or gizmo arrows |
| Rotate | Rotate object by Rx, Ry, Rz angles | Modify tab or gizmo rings (press G) |
| Scale | Resize object uniformly or per-axis | Modify tab dialog |
Using the Gizmo
- Click on an object to show the gizmo
- Drag colored arrows to translate (Red=X, Green=Y, Blue=Z)
- Press G to switch to rotation mode
- Drag colored rings to rotate
STL Operations
- Color STL: Change model color for identification
- Duplicate STL: Create copies of models
- Reset STL: Return all models to original positions
Visibility Toggles
| Toggle | Function |
|---|---|
| Show Gizmos | Show/hide manipulation gizmos |
| Show Targets | Show/hide target markers |
| Ground Plane | Show/hide the grid |
| Show Path | Show/hide end-effector trace |
Physics Simulation Pro
Enable realistic object behavior with gravity:
- Click Gravity toggle in Modify tab
- Objects will fall and collide realistically
- Disable when positioning objects, enable for simulation
Modeling & Drawing
Create geometric objects and draw paths directly in the 3D scene.
All modeling and drawing tools require an Arctos Studio Pro subscription.
Creating Primitives Pro
| Primitive | Parameters | Use Case |
|---|---|---|
| Box | Width, Depth, Height, Position | Workpieces, obstacles |
| Cylinder | Radius, Height, Position | Pipes, rods, round parts |
| Polygon | Number of sides, Radius, Height | Hexagonal fixtures, custom shapes |
Drawing Tools Pro
Create Line
- Click Create Line in Modeling tab
- Click points on the ground plane to draw connected segments
- Press Escape to finish
- Use Trajectory tab → Follow Lines/Splines to generate robot path
Create Spline
- Click Create Spline in Modeling tab
- Click points to create smooth curved paths
- Press Escape to finish
Lines create straight segments between points. Splines create smooth curves through points – better for organic shapes.
Create Circle
- Click Create Circle in Modeling tab
- Click on ground plane for center point
- Drag outward to set radius
- Release to create the circle
Create Text
- Click Create Text in Modeling tab
- Enter your text in the dialog
- Choose font and size
- Text is converted to paths for robot following
Measure Tool
Measure distances between any two points:
- Click Measure in Modeling tab
- Click first point
- Click second point
- Distance is displayed in millimeters
Settings & Configuration
Configure robot parameters, calibration, and application preferences.

Robot Configuration
Access from Settings tab → Robot Config:
- Robot Version: Open Loop or Closed Loop
- Gear Ratios: Transmission ratio for each axis
- Axis Inversion: Reverse direction for any axis
- Joint Limits: Min/max angles for each joint
Calibration
Calibrate gear ratios through test movements:
- Click Calibrate Axes in Settings tab
- Select the axis to calibrate
- Enter a test movement (e.g., 90 degrees)
- Click “Run Test Movement”
- Measure actual movement with a protractor
- Enter measured value and click “Calculate New Ratio”
Homing Settings
Configure the homing sequence for each axis:
- Homing speed: How fast to move during homing
- Homing direction: Which way to move first
- Homing sequence: Order of axis homing
- Switch type: Normally open or closed
AI Settings
Configure AI and language model integrations:
- Gemini API Key: Required for VLM control
- Local LLM Path: For offline AI
- Model selection: Choose AI model
- Quantization: 4-bit for GPU, float32 for CPU
GRBL Settings (Open Loop)
Only modify GRBL settings if you understand the configuration. Incorrect settings can damage your robot.
- Steps per degree for each axis
- Maximum feed rates
- Acceleration values
- Soft limits
MKS Settings (Closed Loop)
Configure MKS servo driver parameters:
- CAN ID for each axis
- Motor current limits
- Encoder settings
- PID tuning parameters
Application Settings
- Dark Mode: Toggle light/dark theme
- Console: Show/hide Python output panel
- Account: Login to unlock Pro features
Console Panel
The Console panel displays Python script output, status messages, and debugging information:
- Access: Settings tab → Console toggle
- Output: Shows print() statements from Python scripts
- Errors: Displays error messages and tracebacks
- Status: Shows robot connection and operation status

Use print() statements in your Python scripts to debug. Output appears in the Console panel in real-time.
Troubleshooting
Common issues and solutions for Arctos Studio Pro.
Connection Issues
Symptoms: CANable adapter not recognized, connection timeout
Solutions:
- Ensure CANable drivers are installed (check Device Manager)
- Try a different USB port
- Check CAN bus termination resistors
- Verify all motor drivers are powered and CAN IDs are correct
- Check CAN bus wiring (CANH to CANH, CANL to CANL)
Symptoms: Arduino not detected, serial port errors
Solutions:
- Install Arduino drivers (CH340 or FTDI depending on board)
- Check that GRBL firmware is properly flashed
- Verify baud rate is set to 115200
- Try a different USB cable (some are charge-only)
Solutions:
- Open Device Manager and check for unknown devices
- Install the appropriate USB-to-serial driver
- Try unplugging and replugging the USB cable
- Restart Arctos Studio after connecting hardware
Movement Issues
Solutions:
- Check motor wiring polarity
- Verify joint direction settings in MKS driver configuration
- For open loop: check GRBL direction invert settings ($3)
Solutions:
- For closed loop: Check encoder connections and calibration
- For open loop: Verify steps/degree settings match gear ratios
- Check for mechanical backlash in gearboxes
- Ensure motor current is sufficient (not skipping steps)
Cause: Target position is outside robot’s reachable workspace
Solutions:
- Move target closer to robot base
- Check that target is within the work envelope
- Try a different orientation for the end-effector
Software Issues
Solutions:
- Update graphics drivers to latest version
- Ensure OpenGL 4.0 or higher is supported
- Try running as Administrator
- Delete settings folder and restart:
%APPDATA%\ArctosStudio
Solutions:
- Update graphics drivers
- Disable hardware acceleration in preferences
- Check that your GPU supports OpenGL 4.0
- Try switching between integrated and dedicated GPU
Solutions:
- Ensure you’re logged in with your Arctos Robotics account
- Check your subscription status at arctosrobotics.com
- Try logging out and back in
- Check internet connection for license verification
Vision & Camera Issues
Solutions:
- Check camera is connected and powered
- Install camera drivers if required
- Close other applications using the camera
- Try a different USB port
Solutions:
- Install Kinect SDK 1.8 from Microsoft
- Ensure Kinect has adequate power (use powered USB hub if needed)
- Check that no other application is using the Kinect
- Try the freenect backend as alternative
Getting Help
Changelog
Complete version history of Arctos Studio Pro with all features, improvements, and bug fixes.
✨ New Features
- Joystick Button Mapping – Enhanced joystick control with customizable button assignments
- RGB Camera Depth Estimation – Monocular depth estimation from standard RGB cameras
🐛 Bug Fixes & Improvements
- Library loading fix – Improved robot and gripper library stability
- MKS settings fix – Resolved configuration issues for closed loop control
- Icons enlarged – Better visibility and usability across the interface
- Loading screen fix – Smoother startup experience with optimized initialization
✨ New Features
- VLM (Vision Language Model) integration
- Depth Sensing with Kinect v1 SDK and RealSense SDK
- Real-time Collision Avoidance
- Digital Twin simulation
- Direct CAN two-way communication
- Coordinate Frames support
- Custom Grippers
- Measure Tool
- Arctos 7th Axis support
- Joystick Interactive UI with multiple button mapping
- IK Movement Buttons
- Initialization Time Optimization
- New Loading Screen
- Python Calls in robot programming
- Bambu Lab API Integration
- Custom LLM with offline and Gradio implementations
- Sensors implemented visually and with PLC
- Drag & Drop Scenes
- View Cube
🐛 Bug Fixes
- Smoother gizmo control
- Arctos joint limits enabled
- Text rendering improvements
- Homing crash fix
- Trajectory follows active tool instead of downward orientation
- G-code streaming buffer fix
- Import any robot via URDF
- Robot library
- MoveJ, MoveL, MoveC, wait commands
- Post processors (KUKA, Fanuc, UR, Mitsubishi, custom post processor)
- Use any LLM with API
- Coordinate frames
- Fixes: shadows, robot colors immediately load
- B/C axis fix & timings improved
- AI PCB blocks generator
- B/C axes timings fix
- G1 commands added for G-code (Feedrate supported)
- Program and real robot sync
- Better shaders
- Faster boot
- MKS settings fix
- Plugins feature added
- Custom robot colors
- Linux (Ubuntu 24.04) distribution
- MKS settings (closed loop)
- Calibration axes fix
- BC axes fix
- Preferences dialogs size fix
- Extract tar.gz to Desktop
- Run:
chmod +x build_shortcut.sh - Launch Arctos Studio from applications list
- Gesture control
- Collision prevention
- STL/SVG gizmo fix
- Object picking by RGB camera
- Circle drawing
- Text drawing
- Bug report
- Python commands from TCP server
- PLC hardware support (Arduino Uno, Mega, ESP32) – Download firmware
- Closed loop gripper commands fix
- 3D printing E axis implemented
- New splash screen
- Resolved CAN disconnecting issue
- Updater won’t self-download if already installed
- Open loop/Closed loop toggle in ribbon
- Updater fix – all versions below this will not get updates correctly
- Load program fix
- Gripper (open loop) fix
- CAN bus fix
- Subscription page fix
- Add gripper fix
- Voice control
- Night mode
- Custom gripper G-code
- AI control
- Python programming
- PLC programming
- Reinforcement learning
- Computer vision
- 3D printing support
- Welding
- Path following
- Multiple robots
- Joystick control
- Physics simulation
- Multiple gripper support
- Conveyor belt support
- Basic shape modelling
- Line drawing and following
- Library
- New Ribbon UI
- Better shaders
- Trajectory tracing
- Model coloring
- Robot gizmo easier control
- IK sliders
- Gear reduction can go > 100
- Fixed CAN Messages – Improved communication stability
- Gear Ratio & Axis Inversion Settings
- Calibration Tools
- GRBL Settings Integration
- Homing Settings
- Solved CAN bus issues
- Added gripper CAN messages
- Added STL import
- Included STL into the Program tree
- Added collision detection
- New top bar
- Pick and place operations
- Console input
- Enhanced 3D Viewer
- Interactive Gizmo
- Advanced Slider Controls
- Dedicated Gripper Controls
- Direct Robot Control
- Fix for the CANable Adapter
- Program Editor Enhancements
- Adjustable Motion Parameters
- Forward & Inverse Kinematics (FK & IK)
- GRBL & CAN Bus Support
- Gripper Controls

