Arctos Studio Pro – Software Documentation
v2.8 Pro
Ctrl+K

Arctos Studio Pro Documentation

Powerful robot simulation, programming, and control software for the Arctos robot arm.

Welcome to Arctos Studio Pro

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

Free Version – Free Forever!

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:

Digital Twin

Real-time synchronization between simulation and physical Closed Loop robot.

Collision Prevention

Active collision blocking that stops movements before impact.

VLM Control

Natural language robot control with Gemini vision AI.

AI & LLM Integration

ChatGPT, Claude, Gemini, or local LLMs like Qwen3.

Depth Cameras

Kinect v1 and Intel RealSense point cloud support.

Advanced Trajectories

SVG paths, welding, 3D printing, circles, and splines.

Modeling Tools

Create boxes, cylinders, text, lines, splines, and circles.

Post Processing

Export to FANUC, KUKA, ABB, Universal Robots, G-code.

Bambu Lab Integration

Automated print farm workflows with MQTT.

Gym (RL Training)

Reinforcement learning environment for robot training.

YOLO Object Detection

AI-powered multi-object detection and tracking.

Physics Simulation

Realistic gravity and object interactions.

What’s New in v2.7

Vision Language Model (VLM)

Control your robot with natural language commands. The VLM system uses image analysis to detect and manipulate objects.

Depth Sensing

Support for Kinect v1 SDK and Intel RealSense cameras for 3D point cloud generation and object detection.

Real-time Collision Avoidance Pro

Integrated collision detection prevents the robot from hitting objects in the scene with configurable safety margins.

Digital Twin

Real-time synchronization between physical and virtual robots with comprehensive scene state management.

Coordinate Frames

World, Tool, and custom coordinate frames with parent-child relationships and robot-attached frames.

Enhanced Joystick UI

Interactive joystick visualizer with real-time button feedback, analog stick display, and button combinations.

Key Features

Multi-Robot Control

Simulate and control multiple robots in the same environment with independent programming.

Conveyor & PLC

Integrate conveyor belts and use the built-in PLC for complex automation systems.

3D Printing & Paths

Slice 3D models and generate toolpaths, or follow paths from SVG files.

Python Scripting

Write and execute Python scripts for ultimate control and flexibility.

System Requirements

ComponentMinimumRecommended
Operating SystemWindows 10Windows 10/11
ProcessorIntel Core i5Intel Core i7
Memory (RAM)8 GB16 GB
GraphicsOpenGL 4.0Dedicated GPU
Disk Space1 GB2 GB

Community & Support

Installation

Download and install Arctos Studio Pro on your system.

Arctos Studio Pro Installation
Arctos Studio Pro main interface after installation

Download

Download the latest version of Arctos Studio Pro from the official website:

Download Arctos Studio Pro

Installation Steps

Double-click the downloaded installer file and follow the on-screen instructions.

Important: Install for All Users

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.

Admin Privileges

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.

Account Panel
Account panel

How to Log In

  1. From the Settings tab in the ribbon menu, click on the Account icon to open the Account panel
  2. Enter your username and password
  3. Click the “Login” button

Once you are logged in, all the Pro features will be unlocked and available for you to use.

No Account Yet?

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.

Tip

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.

Arctos Studio Interface
Arctos Studio Pro main interface showing the ribbon menu, 3D viewer, and program tree

The Ribbon Menu

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

Ribbon Tabs
Ribbon tabs: File, Connections, Program, Modify, Trajectory, Modeling, Robot, and Settings
TabPurposeKey Features
FileScene & project managementNew/Open/Save Scene, Import STL/SVG, Library, Import Robot/Gripper, Plugins
ConnectionsRobot hardware communicationOpen Loop/Closed Loop selection, Port selection, Connect/Disconnect, Digital Twin
ProgramRobot programmingRecord/Update Target, MoveJ/MoveL/MoveC, Run/Stop Program, Pick/Place, Post Process
ModifyObject manipulationMove/Rotate/Scale, Color STL, Collision Check/Prevention, Physics, Show Path
TrajectoryPath generationFollow SVG/Lines/Circles, 3D Print, Slice Model, Welding paths
ModelingCreate objectsCreate Box/Cylinder/Polygon, Draw Lines/Splines/Circles, Create Text, Measure
RobotAdvanced featuresConveyor, Sensors, Camera, Depth Camera, PLC, Joystick, VLM, Gym, Bambu Lab
SettingsConfigurationRobot 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:

Mouse Navigation
Mouse controls for navigating the 3D viewer
ActionMouse ControlDescription
OrbitLeft-click + dragRotate the camera around the scene
PanRight-click + dragMove the view left/right/up/down
ZoomMouse wheelZoom in and out
SelectLeft-click on objectSelect objects to show manipulation gizmo
Gizmo ModePress GToggle 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.

PanelDescriptionAccess
Program TreeManage sequences, targets, and modelsAlways visible (right side)
Joint ControlDirect joint angle control with slidersAlways visible (left side)
IK ControlEnd-effector position/rotation controlAlways visible (left side)
Camera PanelWebcam feed and computer visionRobot tab → Camera
Depth CameraKinect/RealSense point cloudRobot tab → Depth Camera
Conveyor BeltConveyor control and settingsRobot tab → Conveyor
PLC PanelVisual logic programmingRobot tab → PLC
Python PanelScript editor and executionRobot tab → Python Program
VLM PanelVision Language Model controlRobot tab → VLM Control
Gripper PanelGripper offset configurationFile tab → Gripper Settings
Coordinate FramesWorld/Tool/Custom framesProgram tab → Coordinate Frames

Program Tree

Program Tree
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
Quick Actions

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

ShortcutAction
RRun program
SStop program
GToggle gizmo mode (translate/rotate)
Ctrl+SSave scene
Ctrl+OOpen scene
DeleteDelete selected object
Ready to Go!

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

Connections Tab
Connections tab with robot type selection, port dropdown, and connection controls
  1. Navigate to the Connections tab in the Ribbon Menu
  2. Choose Robot Version: Select “Open Loop” or “Closed Loop” from the dropdown
  3. Select Port: Choose the correct communication port for your robot
  4. 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.

Multi-Robot Environment
Multi-robot environment with multiple Arctos arms 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

  1. Connect CANable adapter to USB port
  2. Select “Closed Loop” in the Connections tab
  3. Choose the CANable COM port from dropdown
  4. 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

  1. Connect Arduino to USB port
  2. Select “Open Loop” in the Connections tab
  3. Choose the Arduino COM port
  4. Click Connect
  5. 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.

Digital Twin synchronization – physical robot mirrors simulation in real-time
Safety Warning

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.

Closed Loop Only

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

  1. Connect to your Closed Loop robot first (CAN bus)
  2. Click the “Digital Twin” button in the Connections tab
  3. The button stays pressed to indicate it’s active
  4. Move the simulated robot → physical robot follows in real-time
  5. Click again to disable synchronization

Requirements

  • Closed Loop (CAN) robot version – not available for Open Loop
  • Active CAN bus connection
  • Pro subscription

Connection Status

StatusColorMeaning
Disconnected🔴 RedNo connection to robot hardware
Connected🟢 GreenSuccessfully 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

Joint Control Panel
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 Buttons
IK Control Buttons

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:

KeyAction
/ Move in Y axis
/ Move in X axis
Page Up / Page DownMove in Z axis

Interactive Gizmo

Click on the end-effector in the 3D view to show the manipulation gizmo:

Translate Gizmo
Translate Mode
Drag arrows to move in X, Y, Z
Rotate Gizmo
Rotate Mode
Press G to toggle, drag rings to rotate
Smoother Gizmo Control

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.

New in v2.7

The joystick system has been completely redesigned with an interactive visualizer and button combination support.

Joystick control with real-time robot movement

Setup

  1. Connect a compatible gamepad (PlayStation, Xbox, or generic USB controller)
  2. Go to Robot tab → Click Joystick button
  3. Select your controller from the dropdown
  4. 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 InputDefault Mapping
Left Stick XRobot X translation
Left Stick YRobot Y translation
Right Stick YRobot Z translation
TriggersGripper open/close
D-PadJoint 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.

Program Tab
Program tab with target recording buttons and the Program Tree showing recorded targets

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.

Coordinate Frame Aware

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.

  1. Move the robot to the desired position using Joint sliders, IK controls, or the gizmo
  2. Set the gripper state (open/closed) if needed
  3. Click Record Target in the Program tab (or press T)
  4. The target appears in the Program Tree on the right
  5. 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:

  1. Click Add Wait in the Program tab
  2. Choose wait type: Time Delay (seconds) or Wait for IO (sensor input)
  3. Configure the wait condition
  4. Click Add – the wait command appears in Program Tree

Python in Programs Pro

Advanced Feature

Embed Python code directly in your robot programs for complex logic, calculations, and external system integration.

  1. Click Add Python in the Program tab
  2. Write your Python code in the dialog
  3. Click Add – the Python block appears in Program Tree
  4. Code executes when the program reaches this point
Python
# Example: Conditional gripper control if part_detected(): set_gripper(100) # Close gripper else: print(“No part detected!”)

Post Process Pro

Export your program to robot-specific formats for industrial robots:

Robot BrandOutput Format
FANUC.LS files
KUKA.SRC files
ABBRAPID code
Universal Robots.script files
CNC/3D PrintingG-code

Editing Programs

Program Editing
Program editing controls in the ribbon
  • 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

Direct Control vs Simulation
Direct control mode sends commands to the physical robot; Simulation mode runs in software only

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
With Digital Twin Enabled

The physical robot will move! Ensure workspace is clear before running programs.

Custom Grippers

Load and configure custom gripper models for your robot.

Gripper control and animation

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 FileImport 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:

CAN Commands
# Gripper control via CAN bus # Position range: 0 (open) to 100 (closed) # Python API commands: set_gripper(0) # Fully open set_gripper(50) # Half closed set_gripper(100) # Fully closed # Or use convenience functions: open_gripper() # Same as set_gripper(0) close_gripper() # Same as set_gripper(100)

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:

G-Code
M97 B0 T2 ; Open gripper (position 0) in 2 seconds M97 B40 T2 ; Close gripper to position 40 in 2 seconds M97 B100 T1 ; Fully close (position 100) in 1 second

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.

New in v2.7

The coordinate frame system has been completely redesigned with support for parent-child relationships and robot-attached frames.

Coordinate Frames panel showing frame list and 3D visualization of frame axes

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:

  1. Select the Tool frame in the Frames panel
  2. Adjust position offset (X, Y, Z in mm)
  3. Adjust rotation offset (Rx, Ry, Rz in degrees)
  4. The trajectory will now follow the tool tip instead of the flange
Trajectory Fix

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.

Pro Feature

Real-time collision prevention requires an Arctos Studio Pro subscription. Collision Check (visual only) is available in the free version.

Collision avoidance in action – robot automatically avoids obstacles

Collision Check vs Prevention

FeatureCollision CheckCollision Prevention Pro
FunctionVisual feedback onlyActively blocks movements
IndicationColliding parts turn redMovement is stopped/reverted
Use casePath verificationSafe 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)

  1. Go to Modify tab
  2. Click Collision Check toggle
  3. Move the robot – colliding parts highlight in red

Collision Prevention (Active) Pro

  1. Go to Modify tab
  2. Click Collision Prevention toggle
  3. The system now blocks movements that would cause collisions
  4. 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:

  1. Connect and enable Depth Camera (Robot tab → Depth Camera)
  2. Enable Collision Prevention (Modify tab)
  3. Point cloud data is used for collision detection
  4. Robot avoids both virtual objects AND real-world obstacles

Settings

SettingDefaultDescription
Safety Margin30mmMinimum clearance from objects
Approach Height150mmHeight above objects for approach
Retreat Height200mmHeight for safe retreat movements
Safety Note

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:

  1. Select camera from dropdown (Simulated or Real Camera 0, 1, etc.)
  2. Click “Connect” to start the feed
  3. Enable detection features as needed
Camera Panel
Camera panel showing live webcam feed with detection options

OpenCV Detection Modes

ModeDescriptionUse Case
Color DetectionFilter by red, green, blue, yellow, etc.Sorting by color
Shape DetectionDetect boxes, circles, trianglesPart identification
Contour DetectionFind object outlinesEdge-based picking

Camera Calibration

For accurate robot-camera coordination:

  1. Use QR code calibration for automatic alignment
  2. Or manually set camera-to-robot transform
  3. Calibration data is saved with the scene

YOLO Object Detection Pro

Pro Feature

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

  1. Open Camera panel
  2. Enable “YOLO Detection” toggle
  3. Objects are detected and labeled in real-time
  4. 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

Pro Feature

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

  1. Install Kinect SDK 1.8 from Microsoft (Windows) or freenect drivers
  2. Connect Kinect to USB port (requires USB 2.0+ and external power)
  3. Open Depth Camera panel
  4. Select “Kinect SDK” or “Freenect” backend
  5. 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

  1. Install Intel RealSense SDK 2.0
  2. Connect camera to USB 3.0 port
  3. Open Depth Camera panel
  4. Select “RealSense” backend
  5. 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
Performance Tip

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.

Pro Feature

VLM control requires an Arctos Studio Pro subscription and Gemini API access.

VLM Control panel showing camera feed with detected objects and natural language command input

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

  1. Gemini API Key: Go to Settings tab → AI Settings → Enter your Gemini API key
  2. Camera: Connect a camera via Robot tab → Camera
  3. Depth Camera (recommended): For accurate 3D positioning

Using the VLM Panel

Access from Robot tab → VLM Control:

  1. Ensure camera is connected and showing live feed
  2. Type your command in the input field
  3. Press Enter or click “Execute”
  4. 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
Command Examples

“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.

Pro Feature

AI features require an Arctos Studio Pro subscription.

AI assistant generating robot commands from natural language input

Supported AI Providers

Arctos Studio supports multiple AI providers for different use cases:

ProviderBest ForSetup
Google GeminiVLM control, vision tasksAPI key in Settings → AI Settings
OpenAI ChatGPTCode generation, explanationsAPI key in Settings → AI Settings
Anthropic ClaudeComplex reasoning, safetyAPI key in Settings → AI Settings
Local LLMsOffline operation, privacyOllama 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

Community Recommendation

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 SettingsAI 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

Training Process
RL Training Process

The training process involves:

  1. Setting up the training environment with objects and obstacles
  2. Defining what constitutes success (positive rewards) and failure (negative rewards)
  3. Running the training algorithm (PPO recommended)
  4. Monitoring training progress and adjusting parameters
  5. Deploying the trained model for execution

Access from Robot tab → Gym.

Conveyor Belts

Add conveyor belts to your automation setup for realistic factory simulation.

Conveyor belt with speed controls and objects being transported

Adding a Conveyor

  1. Go to Robot tab
  2. Click Conveyor Belt button
  3. A conveyor belt is added to the scene
  4. Use the gizmo to position it in your workspace

Conveyor Panel Controls

ControlFunction
Start/StopControl belt movement
Speed SliderAdjust belt speed (mm/s)
DirectionForward or reverse movement
Show BoundsToggle 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

  1. Add and position a conveyor belt
  2. Enable physics (Modify tab → Gravity)
  3. Place objects on the conveyor
  4. Start the conveyor
  5. Program the robot to pick objects as they pass
  6. Use sensors to trigger pick operations
Tip

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.

PLC Editor
Visual PLC editor showing input, logic, and output blocks connected together

Visual PLC Editor

Access from Robot tab → PLC. The PLC panel provides a visual canvas for building automation logic without code:

Block Types

Block TypeFunctionExamples
Input BlocksRead sensor valuesProximity sensor, Color sensor, Button
Logic BlocksBoolean operationsAND, OR, NOT, XOR
Output BlocksControl actuatorsMotor, Gripper, Conveyor, LED
Timer BlocksTime-based eventsDelay, Pulse, One-shot
Counter BlocksCount eventsUp counter, Down counter

Building Logic

  1. Drag blocks from the toolbox onto the canvas
  2. Connect blocks by dragging wires between ports
  3. Configure block properties (click to select)
  4. Run the PLC logic to test

Adding Sensors

Access from Robot tab → Sensors:

Sensors detecting objects and triggering automation logic
  1. Browse the sensor library
  2. Click a sensor to add it to the scene
  3. Position using the gizmo
  4. 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:

Arduino Bridge Firmware Required

To use PLC with physical Arduino hardware, you need to upload the Arduino Bridge firmware first. Download Arduino Bridge Firmware →

PLC Settings
PLC Settings dialog for Arduino pin mapping and code generation

Supported Hardware

  • Arduino Uno – Tested and recommended
  • Arduino Mega – More I/O pins available
  • ESP32 – WiFi capability for remote control

Setup Steps

  1. Download and install the firmware:
    • Download the Arduino Bridge firmware
    • Extract the ZIP file
    • Open arduino_bridge.ino in Arduino IDE
    • Select your board type (Uno/Mega/ESP32)
    • Upload to your Arduino
  2. Design your logic in the PLC editor
  3. Map pins: Go to Settings tab → PLC Settings
  4. Assign pins: Map PLC inputs/outputs to Arduino pins
  5. Generate code: Click “Generate Code”
  6. Connect hardware: Wire physical sensors and actuators to mapped pins
  7. Test: Run your PLC logic with real hardware
Pin Voltage Warning

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

  1. Add a “Proximity Sensor” input block
  2. Add a “NOT” logic block
  3. Add a “Conveyor Motor” output block
  4. Connect: Sensor → NOT → Motor
  5. Result: Conveyor stops when sensor detects an object
Tip

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.

Pro Feature – New in v2.7

Bambu Lab API integration enables automated print farm operations where the robot removes finished prints.

Bambu Lab panel with MQTT connection status, print progress, and automation triggers

MQTT Connection Setup

Connect to your Bambu Lab printer via MQTT protocol:

  1. Open the Bambu Panel from Robot tab → Bambu Lab API
  2. Enter your printer’s IP Address (find in printer settings)
  3. Enter the Serial Number (on printer label)
  4. Enter the Access Code (from printer network settings)
  5. Click Connect
Finding Connection Details

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:

StatusDescription
IdlePrinter ready, no active print
PrintingPrint in progress
PausedPrint paused by user or error
CompletePrint finished successfully
FailedPrint 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:

TriggerRobot Action
Print CompleteRobot removes finished part from bed
Print FailedRobot clears bed for retry
CustomDefine your own automation rules

Print Farm Workflow Example

  1. Printer completes a print job
  2. Arctos Studio detects “Complete” status via MQTT
  3. Robot program triggers automatically
  4. Robot moves to printer, picks up the finished part
  5. Robot places part in collection area
  6. Printer bed is clear and ready for next job
  7. Cycle repeats for continuous production
Use Case

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.

Pro Features

All trajectory and path following features require an Arctos Studio Pro subscription.

Trajectory Tab
Trajectory tab with path following options

SVG Path Following Pro

Import SVG files and have the robot trace the paths – perfect for drawing, cutting, or engraving:

  1. Go to File tab → Import SVG
  2. Select your SVG file
  3. Position and scale the SVG using the gizmo
  4. Go to Trajectory tab → Click Follow SVG
  5. Targets are generated along the SVG paths
  6. Run the program to execute
SVG Tips

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:

Robot following a drawn line path with generated targets
  1. Draw lines or splines using Modeling tab tools
  2. Go to Trajectory tab → Click Follow Lines/Splines
  3. Targets are generated along your drawn path

Circles Pro

Follow circular paths for round cutting or polishing operations:

  1. Draw a circle using Modeling tab → Create Circle
  2. Go to Trajectory tab → Click Follow Circles
  3. 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.

Welding path creation along model edges with automatic tool orientation

Getting Started with Welding

  1. Import your STL model (the workpiece to weld)
  2. Define the welding tool length in settings
  3. Click Show Edges to activate edge selection mode
  4. Hover over the model – edges highlight as you move
  5. Click an edge to select it (turns blue)
  6. 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
Best Practices

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:

3D printing slicer with layer visualization and toolpath generation
  1. Import an STL model
  2. Select the model
  3. Go to Trajectory tab → Click Slice Model
  4. Configure slicing parameters
  5. Click “Slice” to generate toolpath visualization
  6. Click Create Targets to generate robot program

Slicing Parameters

ParameterRangeDescription
Layer Height0.1-0.3mmThickness of each layer
Print Speed10-100 mm/sMovement speed while extruding
Infill0-100%Interior fill percentage
Perimeters1-5Number of outline passes
Note

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.

Measure tool showing distance measurement between two points

Activating the Tool

  1. Go to Modeling tab
  2. Click Measure button
  3. The measure tool is now active

Using the Measure Tool

  1. Click on the first point (on any object, frame, or point cloud)
  2. Click on the second point
  3. 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

Python
# Move joints to specific angles move_joints([90, 0, -45, 0, 90, 0]) # Move end-effector to position (meters) translate_ik(0.3, 0.1, 0.2) # Control gripper (0=open, 100=closed) set_gripper(80) # Record current position as target record_target() # Run the program run_program()

Working with Objects

Python
# Create objects create_box(0.2, 0.1, 0.025, 0.05, 0.05, 0.05) create_cylinder(0.3, 0, 0.05, 0.025, 0.1) # List and select models models = list_models() select_model(‘my_box’) # Manipulate models translate_model(0.01, 0, 0) rotate_model(0, 0, 45) color_model(‘red’)

Advanced Features

Python
# Get current state joints = get_joint_values() pos = get_translation() rot = get_rotation() # Smooth transitions with_transition(translate_ik, 0.3, 0.1, 0.2, total_steps=50) # Multi-robot control add_robot(0.5, 0, 0, 0) select_robot(1) move_joints([45, 0, 0, 0, 0, 0]) # Emergency stop stop() # Halts ALL operations

Python API Reference

Complete reference for all Python commands available in Arctos Studio.

Screenshot: Python panel with API commands being executed
Python scripting panel showing API commands in action

Movement Commands

CommandDescription
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

CommandDescription
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

CommandDescription
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

CommandDescription
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

CommandDescription
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

CommandDescription
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

CommandDescription
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

CommandDescription
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

CommandDescription
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

CommandDescription
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.

File Ribbon Tab
File tab with scene management and import options

Scene Management

ActionDescriptionShortcut
New SceneCreate fresh, empty workspace
Open SceneLoad a saved .arctos fileCtrl+O
Save Scene AsSave workspace to .arctos fileCtrl+S
Save Before New Scene

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:

  1. Click Import Model in File tab
  2. Select your .stl file
  3. Model appears at origin (0, 0, 0)
  4. Use gizmo or Modify tools to position

SVG Files

Import 2D vector graphics for path following:

  1. Click Import SVG in File tab
  2. Select your .svg file
  3. SVG appears on ground plane
  4. Use Trajectory tab → Follow SVG to generate robot path

Library

Library Panel
Library panel with robots, grippers, models, and sample scenes

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

Plugins Panel
Plugins dialog showing installed and available plugins

Extend Arctos Studio functionality with community and custom plugins:

  1. Click Plugins in File tab
  2. Browse installed and available plugins
  3. Toggle plugins on/off with checkboxes
  4. Some plugins may require restart

Community Plugins

Find and download community plugins from the official repository:

Arctos Studio Plugins Repository

Installing Plugins

  1. Download the plugin .py file from the repository
  2. Place it in the plugins folder in your Arctos Studio installation
  3. Restart Arctos Studio
  4. Enable the plugin in File tab → Plugins
Plugin Development

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:

Modify Tools
Modify tab with Move, Rotate, Scale, and other object manipulation tools

Transform Tools

ToolFunctionAccess
MoveTranslate object by X, Y, Z valuesModify tab or gizmo arrows
RotateRotate object by Rx, Ry, Rz anglesModify tab or gizmo rings (press G)
ScaleResize object uniformly or per-axisModify tab dialog

Using the Gizmo

  1. Click on an object to show the gizmo
  2. Drag colored arrows to translate (Red=X, Green=Y, Blue=Z)
  3. Press G to switch to rotation mode
  4. 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

ToggleFunction
Show GizmosShow/hide manipulation gizmos
Show TargetsShow/hide target markers
Ground PlaneShow/hide the grid
Show PathShow/hide end-effector trace

Physics Simulation Pro

Enable realistic object behavior with gravity:

Physics simulation with gravity enabled – objects fall and interact realistically
  1. Click Gravity toggle in Modify tab
  2. Objects will fall and collide realistically
  3. Disable when positioning objects, enable for simulation

Modeling & Drawing

Create geometric objects and draw paths directly in the 3D scene.

Pro Features

All modeling and drawing tools require an Arctos Studio Pro subscription.

Creating Primitives Pro

PrimitiveParametersUse Case
BoxWidth, Depth, Height, PositionWorkpieces, obstacles
CylinderRadius, Height, PositionPipes, rods, round parts
PolygonNumber of sides, Radius, HeightHexagonal fixtures, custom shapes

Drawing Tools Pro

Create Line

  1. Click Create Line in Modeling tab
  2. Click points on the ground plane to draw connected segments
  3. Press Escape to finish
  4. Use Trajectory tab → Follow Lines/Splines to generate robot path

Create Spline

  1. Click Create Spline in Modeling tab
  2. Click points to create smooth curved paths
  3. Press Escape to finish
Lines vs Splines

Lines create straight segments between points. Splines create smooth curves through points – better for organic shapes.

Create Circle

  1. Click Create Circle in Modeling tab
  2. Click on ground plane for center point
  3. Drag outward to set radius
  4. Release to create the circle

Create Text

  1. Click Create Text in Modeling tab
  2. Enter your text in the dialog
  3. Choose font and size
  4. Text is converted to paths for robot following

Measure Tool

Measure distances between any two points:

  1. Click Measure in Modeling tab
  2. Click first point
  3. Click second point
  4. Distance is displayed in millimeters

Settings & Configuration

Configure robot parameters, calibration, and application preferences.

Settings Tab
Settings tab with configuration options for robot, calibration, and AI

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:

  1. Click Calibrate Axes in Settings tab
  2. Select the axis to calibrate
  3. Enter a test movement (e.g., 90 degrees)
  4. Click “Run Test Movement”
  5. Measure actual movement with a protractor
  6. 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)

Advanced Users Only

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
Console Panel
Console panel displaying script output and robot status messages
Debugging Tip

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.

Version 2.8 Latest Release

✨ 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
Version 2.7 Previous Release

✨ 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
Version 2.6 Major Release
  • 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
Version 2.5
  • B/C axis fix & timings improved
Version 2.4
  • 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
Version 2.3
  • MKS settings fix
  • Plugins feature added
  • Custom robot colors
Version 2.2
  • Linux (Ubuntu 24.04) distribution
  • MKS settings (closed loop)
  • Calibration axes fix
  • BC axes fix
  • Preferences dialogs size fix
🐧 Linux Installation:
  1. Extract tar.gz to Desktop
  2. Run: chmod +x build_shortcut.sh
  3. Launch Arctos Studio from applications list
Version 2.1
  • Gesture control
  • Collision prevention
  • STL/SVG gizmo fix
  • Object picking by RGB camera
  • Circle drawing
  • Text drawing
  • Bug report
Version 2.0 Major Release
  • Python commands from TCP server
Version 1.9 Rev 2
  • 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
Version 1.8
  • Updater fix – all versions below this will not get updates correctly
  • Load program fix
  • Gripper (open loop) fix
Version 1.7
  • CAN bus fix
Version 1.6
  • Subscription page fix
Version 1.5
  • Add gripper fix
Version 1.4 Major Release
  • 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
Version 1.3
  • Fixed CAN Messages – Improved communication stability
  • Gear Ratio & Axis Inversion Settings
  • Calibration Tools
  • GRBL Settings Integration
  • Homing Settings
Version 1.2
  • 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
Version 1.1
  • 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
Version 1.0 Beta Initial Release
  • Forward & Inverse Kinematics (FK & IK)
  • GRBL & CAN Bus Support
  • Gripper Controls