Robot Programming Methods
Teach Pendant, Offline & AI-Based Programming

1. Overview: The Robot Programming Landscape

Industrial robot programming has undergone a profound transformation over the past decade. What began as a discipline requiring deep expertise in proprietary teach pendant interfaces and vendor-specific code has expanded into a multi-paradigm ecosystem encompassing visual block-based editors, Python-driven frameworks, simulation-first offline workflows, and -- most recently -- AI systems that convert natural language instructions into executable robot programs.

This evolution is driven by a fundamental market reality: the global shortage of robotics engineers. The International Federation of Robotics (IFR) estimates that fewer than 120,000 qualified robot programmers serve a global installed base of over 4.2 million industrial robots. In APAC, this gap is particularly acute -- Vietnam, Thailand, and Indonesia collectively have fewer than 3,000 certified robot programmers for a rapidly expanding automation sector. New programming paradigms are essential to democratize robot deployment and reduce the bottleneck that programming expertise creates in automation project timelines.

Each programming method carries distinct trade-offs across five critical dimensions: programming speed, motion precision, offline capability (programming without stopping production), required skill level, and scalability across robot fleets. Understanding these trade-offs is the foundation for selecting the right approach for a given application, production volume, and team capability.

2. Online Teach Pendant Programming

2.1 The Traditional Paradigm

Teach pendant programming remains the most widely used method for industrial robot programming worldwide. The operator physically stands at the robot cell, uses a handheld pendant (controller device with screen, joystick, and buttons) to jog the robot to desired positions, records those positions as waypoints, and then constructs a motion program by sequencing waypoints with logic, I/O commands, and process parameters.

Every major robot manufacturer ships a teach pendant with their controllers: ABB's FlexPendant, FANUC's iPendant, KUKA's smartPAD, Yaskawa's YRC series pendant, and Universal Robots' Polyscope tablet. While the physical form factors and software interfaces differ, the core workflow is consistent: jog, record, sequence, test.

2.2 Teach Pendant Workflow

1. Cell setup: Mount the robot, install end-effectors, define tool center point (TCP) and workpiece frames using 3-point or 6-point calibration methods.
2. Waypoint teaching: Jog the robot in joint mode or Cartesian mode to each desired position. Record positions with descriptive names (e.g., pPickApproach, pPickGrasp, pPlaceRelease).
3. Program construction: Sequence waypoints into a program using the pendant's editor. Add motion types (joint move, linear move, circular interpolation), speed/acceleration parameters, I/O triggers, conditional logic, and loop structures.
4. Dry run: Execute the program at reduced speed (typically 10-25%) to verify paths, check for collisions, and confirm I/O timing.
5. Production tuning: Incrementally increase speed while monitoring cycle time, path accuracy, and vibration. Fine-tune blend radii and acceleration profiles.

2.3 Advantages and Limitations

3. Hand-Guiding & Direct Teach

3.1 Kinesthetic Teaching

Hand-guiding (also called lead-through programming or kinesthetic teaching) allows the programmer to physically grasp the robot's end-effector or a dedicated handle and move the robot through the desired path. The robot records either discrete waypoints or continuous trajectory data as the operator guides it. This method has surged in popularity with the rise of collaborative robots (cobots), which are designed with force-torque sensors and compliant actuators that make hand-guiding natural and safe.

Universal Robots pioneered accessible hand-guiding with their freedrive mode, where pressing a button on the back of the teach pendant releases all joint brakes and enables zero-gravity mode. The operator can then move the robot freely while the system records joint positions at configurable sampling rates (typically 10-500 Hz). FANUC's CRX series, ABB's GoFa/SWIFTI cobots, and KUKA's LBR iiwa all offer similar hand-guiding capabilities with varying levels of sophistication.

3.2 Force-Torque Sensor Methods

Higher-precision hand-guiding systems use 6-axis force-torque sensors mounted at the wrist to detect operator intent. These sensors enable features like:

• Gravity compensation: The robot actively compensates for the weight of the end-effector and any held workpiece, so the operator feels only the inertia of the arm itself.
• Constrained motion: The programmer can restrict hand-guiding to specific axes (e.g., only Z-axis movement) or planes, useful for teaching surface-following paths.
• Force recording: Beyond position, the system records the forces applied during teaching, enabling force-controlled operations like polishing, deburring, or assembly insertion where compliance is required.
• Refinement loops: The operator can play back a recorded trajectory and then manually adjust specific segments while the rest of the path is maintained, enabling iterative refinement.

4. Offline Programming (OLP)

4.1 The Case for OLP

Offline programming (OLP) is the practice of creating, testing, and validating robot programs on a computer using simulation software -- without requiring access to the physical robot. This is the single most impactful advancement for production environments, because it eliminates the fundamental conflict between programming and production: the robot can continue running its current program while the next program is being developed in simulation.

For high-mix manufacturing environments where product changeovers occur daily or weekly, OLP reduces changeover programming time by 60-80% compared to teach pendant methods. The return on investment for OLP software typically ranges from 6-12 months for facilities running more than 4 product variants per robot cell.

4.2 Leading OLP Platforms

4.3 ABB RobotStudio Deep Dive

ABB's RobotStudio deserves special attention because it runs the actual ABB virtual controller (VirtualController technology) -- the same firmware that runs on the physical IRC5/OmniCore controller. This means programs developed in RobotStudio execute with cycle-time-accurate simulation, and the generated RAPID code can be transferred directly to the physical robot with zero modifications in most cases.

Key RobotStudio workflows include:

• Station Builder: Import CAD models (STEP, IGES, ACIS) for robots, fixtures, workpieces, and conveyors. Define tool frames, work objects, and safety zones.
• Path Auto-Generation: Generate robot paths from CAD geometry -- following edges, surfaces, or curves automatically. Critical for welding seam following, painting spray paths, and machining toolpaths.
• Reachability Analysis: Visualize the robot's workspace envelope with actual joint limits and identify unreachable positions before physical installation.
• Collision Detection: Real-time collision monitoring during simulation with configurable safety margins.
• Signal Analyzer: Debug I/O logic and PLC communication timing alongside robot motion.

5. Block-Based Visual Programming

5.1 The Democratization of Robot Programming

Block-based visual programming represents the most accessible entry point to robot programming. Inspired by platforms like MIT Scratch and Google Blockly, robot manufacturers have developed drag-and-drop interfaces that allow operators with no coding experience to create functional robot programs by assembling pre-built instruction blocks.

This paradigm is particularly significant for small and medium enterprises (SMEs) that cannot afford dedicated robotics engineers. A production line operator can learn to create and modify basic pick-and-place, palletizing, or machine-tending programs within 1-2 days of training, compared to the 2-4 weeks required for proficiency in traditional teach pendant coding.

5.2 Universal Robots Polyscope

Universal Robots' Polyscope interface is the gold standard for visual robot programming. The PolyScope GUI presents a program as a hierarchical tree of instruction nodes. Operators build programs by selecting from categories of nodes: Move (waypoints), I/O (set/wait digital signals), Flow (if/else, loops, subprograms), Wait (time delays, sensor conditions), and URCap nodes (third-party plugin commands for grippers, vision systems, etc.).

Key Polyscope features that drive adoption:

• Wizard-based setup: Guided workflows for TCP definition, payload configuration, and mounting orientation eliminate complex calibration math.
• Freedrive button: Physical button enables instant hand-guiding for waypoint teaching -- operator moves robot, presses "set waypoint," continues.
• URCap ecosystem: Over 400 certified third-party plugins for grippers (Robotiq, OnRobot, Schmalz), vision (Cognex, Photoneo), and force sensing -- each adding custom nodes to the visual programming tree.
• Simulation mode: Programs can be tested in simulation before physical execution, with 3D visualization of the robot path.

5.3 FANUC CRX Visual Programming

FANUC's CRX collaborative robot series features a tablet-based visual programming interface that takes simplicity even further. Programs are constructed by dragging icon-based instruction tiles into a timeline. The interface supports drag-and-drop waypoint creation combined with hand-guiding: the operator physically moves the robot, taps the "add position" icon on the tablet, and the waypoint is automatically inserted into the program flow.

FANUC's approach is notable for maintaining full backward compatibility with their TP (Teach Pendant) language -- the visual program compiles to standard TP code, allowing experienced FANUC programmers to inspect and modify the underlying code when advanced customization is needed.

6. Vendor-Specific Languages (RAPID, KRL, TP, INFORM, URScript)

6.1 Language Overview

Every major industrial robot manufacturer has developed its own proprietary programming language. While these languages share fundamental concepts (motion commands, I/O control, variables, loops, conditionals), their syntax, capabilities, and programming paradigms differ substantially. A programmer proficient in ABB RAPID cannot immediately program a KUKA robot without learning KRL, and vice versa. This vendor lock-in is one of the primary motivations for open standards like ROS2 and third-party platforms like RoboDK.

6.2 URScript Example: Force-Controlled Assembly

URScript is notable for its Python-like syntax and real-time execution at 500Hz. Below is a practical example of a force-controlled peg-in-hole insertion -- a common assembly task that demonstrates URScript's force mode and conditional logic capabilities.

6.3 KUKA KRL Example: Multi-Point Welding

7. Python & ROS2 Programming

7.1 The Open-Source Revolution

ROS2 (Robot Operating System 2) has emerged as the de facto standard for open-source robot programming, providing a vendor-neutral framework that abstracts hardware differences behind standardized interfaces. Unlike vendor-specific languages that lock you into a single manufacturer's ecosystem, ROS2 programs can target robots from ABB, FANUC, Universal Robots, Yaskawa, and others through driver packages (ros2_control hardware interfaces).

The combination of Python and ROS2 is particularly powerful for several reasons:

• MoveIt2 motion planning: The MoveIt2 framework provides sampling-based motion planning (OMPL), collision-aware path computation, and Cartesian path planning through a high-level Python API.
• Perception pipeline: Integration with OpenCV, PCL (Point Cloud Library), and deep learning frameworks (PyTorch, TensorFlow) enables vision-guided manipulation.
• Scalability: A single ROS2 program can orchestrate multiple heterogeneous robots, vision systems, conveyors, and PLCs through a unified communication graph.
• Simulation parity: Gazebo (Ignition) and NVIDIA Isaac Sim provide physics-accurate simulation environments that run the same ROS2 code used on physical robots.

7.2 Python ROS2 MoveIt2 Example

8. AI/LLM-Based Programming

8.1 Natural Language to Robot Code

The most transformative development in robot programming is the emergence of AI systems -- particularly large language models (LLMs) -- that can convert natural language task descriptions into executable robot programs. This paradigm shift has the potential to make robot programming accessible to anyone who can describe a task in plain English (or Vietnamese, or any natural language).

Several research groups and companies have demonstrated functional natural language-to-robot-code systems:

• Google DeepMind SayCan / RT-2: Grounds language instructions in robot capabilities using affordance functions. The LLM proposes actions, and a value function scores which actions are physically feasible. RT-2 (Robotic Transformer 2) directly outputs robot actions from vision-language inputs.
• Microsoft ChatGPT-for-Robotics: Uses GPT-4 to generate robot control code from natural language prompts, with a feedback loop where the user can iteratively refine the generated code through conversation.
• NVIDIA Eureka: Uses LLMs to automatically generate reward functions for robot skill learning, enabling robots to acquire complex manipulation skills (e.g., pen spinning) through reinforcement learning with LLM-designed rewards.
• Covariant RFM-1: A robotics foundation model trained on billions of real-world robot manipulation episodes, capable of generalizing to novel objects and tasks from language instructions.
• Viam + LLM Integration: The Viam platform provides an API layer that allows LLMs to generate robot control commands using a standardized interface across heterogeneous hardware.

8.2 Practical LLM-to-Robot Workflow

A practical implementation of LLM-based robot programming involves several key components:

8.3 Current Limitations and Safety Considerations

Despite remarkable progress, AI/LLM-based programming faces several critical limitations that prevent fully autonomous deployment in production environments:

• Hallucination risk: LLMs may generate plausible-looking but physically impossible or unsafe robot commands (e.g., moving to positions outside the workspace, commanding speeds that exceed joint limits).
• Spatial reasoning gaps: Current LLMs struggle with precise geometric reasoning -- they may misinterpret spatial relationships or fail to account for collision geometry.
• Lack of real-time awareness: LLMs generate plans based on a snapshot of the environment; they cannot react to dynamic changes during execution without re-planning.
• Verification challenge: Validating that LLM-generated code is safe for a specific robot cell configuration requires either human review or formal verification methods that are still in research stages.

9. CAD-to-Path Generation

9.1 Automated Toolpath from 3D Models

CAD-to-path generation automates the creation of robot motion paths directly from 3D CAD models of the workpiece. This method is indispensable for applications where the robot must follow complex 3D surfaces -- spray painting, fiberglass layup, robotic machining, adhesive dispensing, laser cutting, and weld seam following. Instead of manually teaching hundreds or thousands of waypoints, the programmer imports the CAD model, selects the surfaces or edges to follow, defines process parameters, and the software generates a complete robot program.

9.2 CAD-to-Path Workflow

1. CAD import: Import workpiece geometry (STEP, IGES, or native CAD format) into the OLP software. Verify dimensional accuracy against physical part measurements.
2. Feature selection: Select edges (for welding/cutting), surfaces (for painting/coating), or curves (for dispensing) that define the robot path.
3. Tool orientation: Define the tool approach angle relative to the surface normal. For spray painting, this is typically 90 degrees to the surface; for welding, the torch angle may be 15-45 degrees from normal.
4. Process parameters: Assign speed profiles (variable speed based on curvature), process triggers (gun on/off, laser power), and overlap patterns for area coverage.
5. Path generation: The software computes waypoints at configurable density (e.g., every 2mm for high-precision paths, every 10mm for painting) and generates the robot program in the target vendor language.
6. Reachability check: Verify that all generated waypoints are reachable by the robot without singularity, joint-limit, or collision issues.
7. Post-processing: Convert the generic path to vendor-specific code (RAPID, KRL, TP, etc.) using a post-processor tailored to the target controller.

9.3 Adaptive Path Correction

Real-world workpieces rarely match their CAD geometry exactly. Thermal distortion, fixture variations, and manufacturing tolerances create discrepancies between the programmed path and the actual part surface. Adaptive path correction systems use real-time sensor feedback to adjust the robot path during execution:

• Laser seam tracking: A laser sensor mounted ahead of the welding torch scans the joint geometry and adjusts the robot path in real-time. Systems from Meta Vision, Servo-Robot, and Keyence provide 0.1mm accuracy with 200Hz update rates.
• Touch sensing: The robot uses the wire (in welding) or tool tip as a probe to detect the actual workpiece surface before executing the programmed path, applying offsets to correct for fixture drift.
• 3D vision correction: Structured light or stereo vision systems capture the actual part pose before program execution, and the entire path is transformed to match the measured part position and orientation.

10. Simulation-to-Deployment Workflow

10.1 Digital Twin Architecture

The simulation-to-deployment (sim-to-real) workflow is the most robust approach to robot programming for complex applications. The core principle is simple: develop, test, and validate the complete robot program in a simulation environment that mirrors the physical cell with sufficient fidelity, then transfer the validated program to the physical robot with minimal on-site adjustment.

A high-fidelity digital twin includes:

• Kinematic model: Exact robot geometry, DH parameters, joint limits, and velocity/acceleration/jerk limits matching the physical robot's configuration.
• Dynamic model: Inertia properties, friction models, and motor characteristics for cycle-time-accurate simulation. ABB RobotStudio and KUKA.Sim achieve <2% cycle time deviation from physical execution.
• Cell geometry: Accurate 3D models of fixtures, conveyors, safety fencing, cable routing, and all objects within the robot's reach envelope. Sourced from CAD or 3D scanning (LiDAR or photogrammetry).
• I/O and PLC logic: Simulated I/O signals and PLC programs that mirror the physical control architecture, enabling full sequence validation including interlocks and error handling.
• Physics simulation: For applications involving part interaction (bin picking, assembly), physics engines (NVIDIA PhysX, Bullet, MuJoCo) simulate gravity, friction, and contact dynamics.

10.2 Sim-to-Real Transfer Pipeline

11. Skill-Based Programming

11.1 From Programs to Skills

Skill-based programming represents a higher level of abstraction where reusable robot capabilities (skills) are parameterized and composed to create application-specific programs. Instead of programming every waypoint and I/O command, the programmer assembles pre-built skills like "pick from conveyor," "insert pin with force control," or "apply sealant along edge" and configures their parameters for the specific application.

This paradigm is gaining traction in industry through platforms like:

• ABB Wizard Easy Programming: Pre-built skill blocks for common tasks (pick, place, screw driving, dispensing) that operators configure through simple parameter forms rather than code.
• KUKA.AppTech: Application-specific technology packages that encapsulate complex process logic (welding, painting, handling) as parameterized skill modules.
• Franka Emika (now Agile Robots) Desk: Web-based interface where users construct programs from skill "apps" with visual parameter configuration -- pioneered the concept of "app-based" robot programming.
• drag&bot (now NEURA Robotics): Vendor-independent skill-based programming platform that works across robot brands, enabling skills developed on one robot to be redeployed on another.
• ArtiMinds RPS: Robot Programming Suite that combines skill templates with sensor-adaptive execution, particularly strong in force-controlled assembly tasks.

11.2 Skill Composition Architecture

A well-designed skill framework operates in three layers:

1. Primitive skills: Atomic actions like "move linear," "move joint," "grasp," "release," "wait for signal." These map directly to robot controller commands.
2. Composite skills: Sequences of primitives that perform meaningful subtasks. Example: "pick from bin" = approach + lower + grasp + retract + verify. These are parameterized (bin position, approach height, grasp force) and include error handling.
3. Task programs: Compositions of composite skills that define complete applications. Example: "sort parts by color" = detect objects + loop(pick from conveyor + classify color + place in bin[color]). Task programs are the layer visible to the end user.

12. Programming Time Comparison by Method

12.1 Benchmark: Programming Time for Common Applications

The following table compares estimated programming time across methods for three representative applications, based on aggregated data from 80+ industrial deployments across APAC. All times assume a programmer with adequate proficiency in the given method.

* AI/LLM times include human validation and simulation verification. These are current estimates (early 2026) and are improving rapidly.

12.2 Total Cost of Ownership by Method

12.3 Decision Framework

Selecting the right programming method depends on the intersection of four factors:

1. Production volume per variant: High-volume/low-mix favors teach pendant (program once, run forever). High-mix/low-volume demands OLP or AI-assisted methods to minimize changeover time.
2. Path complexity: Simple pick-and-place suits visual programming. Complex 3D paths (welding, painting) require OLP with CAD-to-path. Force-controlled tasks benefit from hand-guiding combined with Python/ROS2.
3. Available expertise: If your team has no coding background, visual programming or skill-based methods are the only viable options. If you have software developers, Python/ROS2 unlocks the most flexibility.
4. Multi-robot scale: For deploying the same application across 10+ robot cells, OLP and skill-based programming provide the scalability that teach pendant methods cannot match.

13. APAC Workforce Training Considerations

13.1 The Skills Gap in Southeast Asia

The robot programming skills gap in APAC is the single largest constraint on industrial automation adoption in the region. Vietnam, with approximately 1,200 certified robot programmers for an economy installing 3,000+ new industrial robots annually, typifies the challenge. Thailand, Indonesia, and the Philippines face similar ratios. This shortage manifests as extended project timelines (6-12 month waits for qualified integrators), inflated labor costs for robotics engineers (2-3x the market rate for equivalent software roles), and over-reliance on vendor-provided programming services.

13.2 Training Programs and Certification

13.3 Vietnam-Specific Workforce Development

Vietnam's robotics workforce development is accelerating through several channels:

• University programs: Hanoi University of Science and Technology (HUST), Ho Chi Minh City University of Technology (HCMUT), and Vietnam National University offer mechatronics and robotics programs. However, curricula lag industry needs -- most programs teach theoretical robotics rather than hands-on industrial programming.
• Vocational training: Vietnam-Korea Industrial Technology Institutes and German-Vietnamese collaboration programs (GIZ) provide practical PLC and basic robot programming training aligned with manufacturing industry needs.
• Vendor boot camps: ABB, FANUC, and Universal Robots have increased training capacity in Vietnam through partnerships with local distributors and system integrators. UR's free online academy has been particularly effective, with over 15,000 Vietnamese registrations since 2023.
• Private sector upskilling: Major FDI manufacturers (Samsung, LG, Canon) run internal robot programming training for Vietnamese technicians, creating a pipeline of skilled workers who later enter the broader job market.

13.4 The Future: Programming-Free Robotics

Looking ahead to 2027-2030, the convergence of AI/LLM programming, advanced simulation, and skill-based platforms is moving the industry toward a future where the concept of "robot programming" as a distinct discipline begins to dissolve. Instead of programming robots, operators will instruct them -- describing tasks in natural language, demonstrating actions through hand-guiding, or selecting from libraries of pre-built skills -- with AI handling the translation to machine-executable commands.

This shift does not eliminate the need for robotics expertise; rather, it redistributes it. Deep programming knowledge will still be required to build and validate the underlying skill libraries, AI models, and simulation environments. But the deployment of those capabilities to individual robot cells will become dramatically faster and more accessible, unlocking automation for the vast number of SMEs and high-mix manufacturers that current programming paradigms cannot economically serve.