ABB RAPID Pack

Modern Visual Studio Code language support and optional controller connectivity for ABB RAPID robot programs.

ABB RAPID Pack turns a folder of RAPID source files or a RobotStudio backup into a navigable codebase. Its offline language features work without a controller profile. When explicitly enabled, the Controller Explorer can connect to supported IRC5 and OmniCore controllers through Robot Web Services (RWS)—without PC SDK or OPC UA.

ABB RAPID Pack is an independent community project. It is not affiliated with, sponsored by, or endorsed by ABB. ABB, RAPID, RobotStudio, and Robot Web Services are trademarks or product names of their respective owners.

Highlights

• Navigate definitions, references, symbols, call hierarchies, and user-defined RECORD types across real multi-file projects.
• Rename symbols with lexical-scope, controller-task, collision, and stale-index checks.
• Use contextual completion, signature help, hover documentation, semantic highlighting, snippets, formatting, diagnostics, and quick fixes.
• Connect through named HTTPS-first profiles whose passwords remain in VS Code SecretStorage.
• Synchronize loaded controller modules into a stable local controller folder suitable for optional Git tracking.
• Inspect and update RAPID data and I/O, select and control RAPID tasks, transfer files, and deploy modules through guarded workflows.
• Monitor selected RAPID variables, I/O signals, execution state, operating mode, motor state, and controller connectivity without continuously polling the entire controller.
• Display and follow RAPID program and motion pointers, and use supported controller breakpoints from VS Code.

Quick start

Work offline

1. Open a folder containing RAPID source files or a RobotStudio backup.
2. Open a .mod, .modx, .sys, .sysx, or .prg file.
3. Use F12 for Go to Definition, Shift+F12 for ABB RAPID Pack references, and F2 for Rename Symbol.
4. Open the ABB RAPID Pack icon in the Activity Bar for References, Settings, and the optional controller views.

No profile or controller connection is required for parsing, highlighting, completion, hover, formatting, diagnostics, symbols, navigation, references, call hierarchy, or rename.

Connect to a controller

1. Open a trusted VS Code workspace.
2. In Controller Explorer > Connection, choose Create Connection Profile….
3. Enter the controller host, RWS port, protocol, generation, and UAS username. The password is saved separately in SecretStorage.
4. Use the plug button on the Connection section or run Connect.
5. On the first connection, select a parent directory for the local controller workspace. The extension creates and reuses a controller-specific folder below it.
6. For mutations, configure the profile as Read & Write, enable its write/execute switch, and use Request Write Access for the active connection.

Creating or selecting a profile never connects automatically. Requesting write access enables extension commands; it does not change the controller's UAS grants, operating mode, signal access configuration, or safety state.

Offline RAPID language features

Editing and type intelligence

• Syntax and semantic highlighting for .mod, .modx, .sys, .sysx, and .prg.
• Context-aware completion for documented built-ins, local declarations, workspace globals, user-defined records, nested members, and named optional arguments.
• Hover and signature help for a deterministic 720-entry RAPID language database and user-defined procedures and functions.
• Deep member resolution for expressions such as Target.trans.x and nested application records.
• Snippets for modules, routines, declarations, control flow, and error handlers.
• Controller-configured procedure discovery from RobotStudio backup SYSPAR/MMC.cfg files.
• Controller-wide I/O symbol awareness from SYSPAR/EIO.cfg and, while connected, a bounded sanitized signal-name, RAPID type, and device catalog. When disconnected, the selected Controller Workspace's SYSPAR/EIO.cfg provides the same offline declarations even if that controller folder was not added as a VS Code workspace folder. Signal values and controller credentials are never sent to the language server.

When connected and the symbol can be resolved unambiguously, RAPID variable hover shows the Live Controller Value before the source declaration's initial value. Out-of-scope or unavailable live values are reported as unavailable rather than guessed.

Hovering a recognized I/O signal shows its signal kind and configured device. While connected, the VS Code controller layer performs a bounded, briefly cached read of only that signal and adds its current value; live values are not forwarded to the language server.

Navigation and refactoring

• Hierarchical document symbols, breadcrumbs, and ranked workspace-symbol search.
• Go to Definition and Type Definition for variables, parameters, constants, routines, traps, records, and record fields.
• Find All References in a dedicated tree, grouped by file with source previews.
• Scope-aware workspace rename with collision, shadowing, stale-index, comment/string, and controller-task isolation checks.
• Incoming and outgoing call hierarchy for user-defined procedures and functions.

Ambiguous navigation and refactoring requests fail without applying speculative changes.

Diagnostics and quick fixes

Diagnostics are deterministic and opt-in through abb-rapid-pack.enableErrorHighlights. Supported checks include:

• lexical and syntax errors, duplicate declarations, invalid block placement, labels, and return statements;
• type mismatches in scalar declarations, assignments, function returns, conditions, loops, array indexes, and TEST values;
• constant/literal initializer rules, invalid declaration modifiers, array dimensions, and writes to constants;
• user-routine argument counts and types, optional argument order and alternatives, switches, and VAR, PERS, and INOUT access modes; and
• unknown record members and member access on primitive values.

Strict unresolved-variable diagnostics and cross-file duplicate-global checks are separate opt-in settings because controller-installed data, add-ins, and task configuration may not be represented in source. The extension is not a complete RobotWare compiler; the controller or RobotStudio Check Program remains authoritative for option-dependent behavior, controller-installed types, and semantic rules that cannot be proven locally.

Formatting

The formatter supports complete documents and safe ranges, uses VS Code indentation settings, and can emit readable spaced operators or compact RobotStudio-style operators. Formatting is disabled until abb-rapid-pack.enableRapidFormatter is enabled. RAPID files contribute ABB RAPID Pack as the default formatter with format on save enabled; the formatter setting remains the final gate.

Controller compatibility

RWS 1.0 and RWS 2.0 use separate endpoints and response parsers. Auto detection probes safe, read-only controller information and fails clearly when the generation is inconclusive. Select the generation explicitly when auto detection is unavailable or the controller returns a nonstandard probe response. Auto detection does not discover the network protocol: select HTTP for a standard IRC5/RWS 1.0 endpoint and HTTPS for OmniCore/RWS 2.0. The profile wizard recommends the matching protocol after the controller generation is selected. HTTPS remains available for a custom IRC5 endpoint that is explicitly known to expose RWS 1.0 over TLS.

Controller preparation

Requirements for a real controller

Before creating a profile, verify the following on the controller and network:

1. Supported RobotWare and RWS generation: IRC5 requires the supported RWS 1.0 resources; OmniCore requires RWS 2.0. Boot-server mode exposes only a limited subset of RWS and cannot load normal RAPID, I/O, subscription, mastership, or execution resources.
2. Reachable RWS endpoint: The PC must be able to reach the configured controller hostname or IP and TCP port. Use a controller network interface that permits RWS traffic. ABB documents that an isolated IRC5 LAN 3 cannot be used by RWS clients.
3. Controller communication options: Confirm the required licensed communication option for the exact controller and RobotWare release. ABB's controller-application guidance identifies 616-1 PC Interface for IRC5 and 3119-1 RobotStudio Connect for OmniCore external PC applications. The extension cannot install, license, or infer every option combination.
4. UAS account: Create or select a controller User Authorization System user in RobotStudio and assign it to a group with the grants required by the intended operations. Do not place the password in settings.json.
5. Controller state: Writes, execution commands, write access, module changes, motor commands, and breakpoints remain subject to the controller's operating mode, task state, safety configuration, and current write-access holder. RobotWare 7 uses mastership. RobotWare 8 uses Control Station write access and requires remote access to be allowed deliberately from the FlexPendant before an external station can obtain it.
6. Workspace Trust: VS Code must trust the workspace before the extension will connect, read live data, transfer files, or issue controller mutations.

ABB's RWS documentation states that all RWS clients authenticate with controller UAS credentials. RWS 1.0 uses Digest authentication and the ABBCX/HTTP-session cookies; RWS 2.0 uses Basic authentication over HTTPS and session cookies. The extension manages those sessions automatically.

Useful official references:

• RWS 1.0 introduction and session requirements
• RWS 2.0 API introduction
• Controller User Authorization System
• ABB controller-application installation requirements

UAS grants and controller permissions

The exact grants enforced by a controller can vary with RobotWare release, installed options, and the requested resource. The following are common grants to verify in RobotStudio; the controller is always authoritative.

The extension's Request Write Access button is an additional local safeguard. It never grants or bypasses controller permissions.

ABB documents that updating RAPID values in Manual mode can require Remote Manual Mode Privilege (RMMP) in addition to RAPID mastership. ABB RAPID Pack does not currently automate the RMMP approval workflow, so a controller can reject a Manual-mode mutation even when the extension shows write access.

Virtual Controller setup

1. Create and start an IRC5 or OmniCore Virtual Controller in RobotStudio.
2. Determine the VC's RWS protocol and port. ABB's RWS 1.0 documentation identifies port 80 as the default IRC5 VC socket port, but it is configurable and multiple VCs on one PC require distinct ports. OmniCore uses HTTPS, but a RobotStudio VC may expose HTTPS on port 80 or another configured port rather than the real-controller default of 443.
3. Create a profile in Controller Explorer > Connection. Use 127.0.0.1 only when VS Code and RobotStudio run on the same computer. From another computer, use the RobotStudio computer's LAN IPv4 address or hostname and allow the VC's RWS port through its firewall. Choose the matching generation or Auto.
4. Use a VC UAS username and password. A Virtual Controller does not require the IRC5 PC Interface option according to ABB's Virtual Controller development guidance.
5. Use HTTPS for OmniCore. Disable certificate validation only for a controlled development VC with a self-signed or hostname-mismatched certificate.
6. Connect and select the parent directory in which the controller-specific workspace should be created. A pre-existing Git repository is not required.

To validate basic reachability before using the extension, open the profile's base URL in a browser. An initial 401 Unauthorized challenge is normal. After signing in, the controller should return an RWS service response. Do not embed credentials in the URL or copy authenticated cookies into logs.

Connection profiles

Profiles are created, selected, edited, and removed from Controller Explorer > Connection or the Command Palette. Profile management does not connect to a controller.

Non-secret profile metadata is machine-scoped. Passwords are never sent to the language server or printed in profile commands, logs, test fixtures, or error messages.

Controller Explorer

The Controller Explorer keeps setup and controller actions together instead of placing connection profiles in the Settings view.

Each section header provides compact command buttons for its own operations. Connection contains profile, connection, and write-access controls; Controller contains state, motor, and warm-start controls; Controller Workspace contains synchronization and file-transfer controls; RAPID contains data, deployment, execution, pointer, and breakpoint controls; and I/O Signals contains filter and creation controls. Context-dependent buttons remain beside their task, module, or signal. The Event Logs output button opens the single consolidated ABB RAPID Pack output channel used by controller actions, deployment, live monitoring, debugging, and the language server. Sections load lazily and distinguish unavailable, loading, empty, and error states. Opening Event Logs reads every reported domain and displays the combined current buffers directly, newest first; ABB event-log domain numbers do not need to be selected manually. Expand an event to inspect its header, description, consequences, causes, recommended actions, source, code, timestamp, and arguments when those fields are provided by the controller. While Event Logs remains expanded and the Controller Explorer is visible, its contents refresh automatically every 2 seconds. The refresh pauses when the section is collapsed, the view is hidden, or the controller is disconnected. Unchanged buffers do not redraw the tree, so an open event tooltip remains visible. Internal controller diagnostics are omitted from this section and written once, with their available detail, to the consolidated ABB RAPID Pack output channel instead. Existing internal diagnostics are treated as the connection baseline and are not replayed; only internal events first observed after that baseline are written. If RWS returns summary and detail representations for the same controller sequence, they are shown as one event with the richer detail. Matching copies reported by Common and a specific domain such as Process or Operational are also shown once; the specific-domain entry is preferred while richer text from Common is retained.

Connection lifecycle and state monitoring

The status bar shows disconnected, connecting, connected, reconnecting, and error states, including the detected controller name and generation when connected. Controller execution, task, operating mode, and motor observations are updated through RWS subscriptions where supported, with one non-overlapping reconciliation read approximately every 30 seconds.

After a connection has succeeded during the current VS Code session, an unexpected loss starts a bounded reconnect sequence. Explicit disconnect, extension deactivation, or exhausted attempts stop reconnecting and revoke connection-scoped write access. The extension does not repeatedly reconnect to a controller that was never successfully connected during the active session.

Controller workspace and Git

On first connection, choose any local parent directory. The extension creates a folder using a safe controller name and stable eight-character identity, then downloads loaded modules into task directories. Controllers with the same IP address do not share synchronization state. The saved parent association is reused across disconnects, reconnects, and later VS Code sessions.

Git is optional. You may initialize a repository before or after synchronization, add the generated controller folder to an existing workspace, or never use Git.

The workspace manifest at .abb-rapid-pack/controller-workspace.json tracks controller-applied and last-observed hashes. Local files are shown as synchronized, unsaved, not applied, or conflicting. Saving changes locally does not write to the controller.

For local file workspaces, synchronization rejects the selected root, manifest, module, EIO, or any existing parent path component when it is a symbolic link or junction, and rejects multiply linked files. Controller-owned writes use same-directory temporary files and atomic replacement where the host filesystem supports it. Choose a regular local directory rather than a linked path.

Automatic synchronization after connection preserves known local pending edits. In contrast, Synchronize Workspace from Controller is an explicit discard-and-refresh action: it replaces the synchronized local module files with the controller's current copies and clears their pending state. Commit, stash, or copy local edits first if they must be retained.

Synchronization uses a RobotStudio-style source layout:

<controller>/
├─ RAPID/TASK1/PROGMOD/    # first controller task's program modules
├─ RAPID/TASK1/SYSMOD/     # first controller task's system modules
├─ RAPID/TASK2/...         # additional tasks use backup-style TASK2, TASK3, ... folders
└─ SYSPAR/EIO.cfg          # generated read-only signal declaration snapshot

The EIO snapshot is built locally from the read-only live signal inventory. It contains signal names and RAPID signal types so the workspace remains useful for Git and offline language intelligence; it is not a byte-for-byte controller configuration export and must not be loaded as a full controller configuration. Existing flat task/module workspaces are migrated on their next successful synchronization. The manifest keeps each backup-style TASK<n> directory mapped to the controller's real task identity (for example, TASK1 can represent T_ROB1), so deployment and live-controller operations continue using the exact RWS task name. Existing RAPID/<controller-task>/... paths are also migrated without discarding pending local edits.

Both PROGMOD and SYSMOD are created for every discovered task, including when one or both are empty. The controller-provided built-in BASE system module is not copied into the workspace; user-loaded program modules and other system modules continue to synchronize normally.

Synchronization covers every loaded RAPID module reported by each task and the live I/O declaration inventory. It is not a complete controller backup and does not recursively download every File Service object, device, log, or other configuration domain.

RAPID tasks, modules, and data

• Select or deselect tasks with their checkboxes. Execution commands apply only to selected tasks.
• Expand tasks to browse modules, then expand modules to browse PROC and FUNC declarations.
• Use the Create RAPID Module button beside a task to create and load an empty program or system module in that specific task. Right-click a loaded module and choose Remove RAPID Module to unload it. Both operations require write access and explicit confirmation, acquire RAPID mastership, and ask separately before stopping running RAPID. They never restart execution automatically. Removing a controller module retains its synchronized local file so source and Git history are not destroyed.
• Open a module from its synchronized local file; without a workspace, it opens as an unsaved downloaded copy.
• Read or write a live RAPID variable from the Command Palette. Use Add to Live Monitor from the editor context menu while the cursor is on either a RAPID variable or an I/O signal. The extension resolves the symbol automatically and asks only when more than one controller value matches.
• Live values are clearly labeled as controller data and never replace source initializers.

RAPID values support booleans, finite numeric values, strings, practical rectangular arrays, and positional records when their shape can be resolved. RECORD watches use source type information to display property names instead of only positional indexes. Malformed, ambiguous, unsupported, or unvalidated values are rejected before a write.

Pending changes and module deployment

Use Upload Module to Controller for one synchronized module or Write All Pending Changes to Controller for the pending set. Deployment never occurs on save alone.

Each deployment:

1. verifies the active file and obtains current language-server diagnostics;
2. blocks on local RAPID errors;
3. asks for or confirms the target task;
4. requires an explicit deployment confirmation;
5. acquires RAPID mastership;
6. checks execution state and separately asks before stopping running RAPID;
7. uploads the raw module, unloads/replaces the existing module, and loads the new module;
8. requests controller build-error details and reads the module back where supported;
9. clears pending state only after verified success; and
10. releases mastership and deletes the temporary controller file in every outcome.

A batch deployment stops at the first failed file and leaves unsuccessful files pending. Diagnostics, controller build errors, ABB codes, and redacted workflow details are written to ABB RAPID Pack Module Deployment. Deployment has no automatic rollback and never restarts execution.

I/O signals

The I/O section loads bounded pages and supports a case-insensitive name filter. Plain text performs a contains search; * and ? act as wildcards. Filtering searches the controller inventory rather than only the currently visible page. Use Load More I/O Signals for the next matching page.

Signal rows display the logical value/state and any type, category, network, unit, physical-state, or quality metadata returned by the controller. Individual writes validate the requested value, read the previous state, and require confirmation. Bulk, pulse, toggle, invert, and delayed writes are not provided.

Create I/O Signal supports DI, DO, AI, AO, GI, and GO when the controller advertises the capability. Simulated signals do not require Device or Device Mapping. A device-mapped signal requires both fields; the controller can still reject unsupported names, mappings, types, or states. After successful signal creation, the extension asks whether to perform a normal controller restart so changed system parameters can take effect. Declining leaves the controller running. Accepting requires active write access; the restart is never hidden or automatic.

RWS is a remote client even when it connects to a controller running on the same PC. For real controllers, the signal's Access Level must permit the applicable Remote Client Auto/Manual write. For a detected Virtual Controller only, the extension may attempt one local-session registration and retry one explicitly confirmed I/O write; it never applies this fallback to a real controller.

Execution, motors, and task selection

The RAPID section provides separate Start Selected RAPID Tasks, Stop Selected RAPID Tasks, and Reset Selected Program Pointers to Main actions. Controller state is refreshed before each command. Start and reset show controller, task, operating mode, execution, and known motor state before confirmation. When possible, starting selected tasks first requests Motors On through the guarded motor workflow. Motors can also be turned on or off explicitly.

An accepted API response does not prove the robot or cell is safe or that motion occurred. Unknown or transitional controller states remain unknown and can disable commands until a valid observation is available.

Controller warm start

Warm Start Controller sends ABB's normal restart mode only. It does not expose I-start, P-start, B-start, shutdown, or automatic restart after deployment. The command requires a connected Read & Write profile, the global write/execute switch, active connection-scoped write access, controller capability, and explicit confirmation. After the controller accepts the request, the current connection and its write-access lease become invalid as the controller session restarts. The existing bounded reconnect flow attempts to restore the connection; ask for write access again after reconnection. The controller remains authoritative and can reject a restart because of UAS authorization or controller state. Command completion confirms only that the controller accepted the request; it does not wait for the complete stop/start cycle. If the request does not produce a conclusive response, the outcome is reported as unknown because the controller may already be restarting, and the extension starts bounded reconnection. Check the controller or RobotStudio state and the controller output before repeating an indeterminate restart request.

For RWS 2.0, RobotWare 7 warm start uses ABB's atomic all-domain mastership resource; RobotWare 8 uses Control Station write access. In Manual mode ABB additionally requires a local-client session and all-domain privileges, so the controller can still reject the command when RMMP/local approval has not been granted.

Live Monitor

Use the single Add Live Watch button and enter either a RAPID variable or I/O signal name. The extension identifies the resource and asks you to choose only when the name is ambiguous. A RAPID variable can also be added by right-clicking it in the editor; an I/O signal can be added from its Explorer row.

Each watch updates in place with its current value and timestamp. Arrays are expandable and known RECORD values use named fields, including practical nested records. Pause/resume retains the watch list and last values. Disconnected, reconnecting, paused, and failed observations are marked stale.

Monitoring subscribes only to selected resources. If subscriptions are unavailable, it falls back to bounded read-only polling of those watches rather than polling every RAPID variable or I/O signal. Monitoring does not require write access. When subscription creation contains both an HTTP location and an explicit WebSocket event URL, the extension uses the WebSocket URL.

Program pointers and controller breakpoints

For synchronized modules, program and motion pointers appear as separate PP and MP editor-line decorations. Use Go to Program Pointer, Go to Motion Pointer, Follow Program Pointer, or Follow Motion Pointer. Follow commands change dynamically to Stop Following… while active and refresh only the active or followed task at a bounded cadence.

The ABB RAPID Controller debug configuration integrates supported controller breakpoints and Continue/Pause controls with VS Code. Breakpoints require a saved module whose local content is fully applied to the controller, active write access, an allowable RAPID state, and brief RAPID mastership.

OmniCore/RWS 2.0 can remove all controller breakpoints after explicit confirmation. RobotWare 6 RWS 1.0 documents breakpoint listing and setting but not removal, so the extension does not pretend a locally removed gutter marker removed the controller breakpoint. Use RobotStudio or another supported controller-side tool to remove IRC5 breakpoints.

File and module transfer

• Upload File transfers the selected local file as raw bytes and confirms controller target, size, and overwrite behavior.
• Download File writes the returned bytes to an explicitly selected local destination.
• Download Module from Controller opens UTF-8 module text in a labeled unsaved editor and offers an explicit Save As action.
• Synchronize Workspace from Controller downloads all loaded task modules into the synchronized controller workspace.

Controller paths are validated against traversal and injection. Raw File Service transfers preserve bytes; module endpoints return decoded controller text and are normalized to UTF-8. Large and malformed responses are rejected before they can overwrite a synchronized module.

Commands and views

Most controller actions are available directly in the Controller Explorer. The corresponding top-level workflows are also available from the Command Palette; row-specific actions such as Load More I/O Signals remain in their relevant view.

The ABB RAPID Pack Activity Bar contains:

• Controller Explorer for connection, controller, workspace, RAPID, and I/O workflows;
• Live Monitor for selected live values;
• References for grouped source references; and
• Settings for offline language and formatter settings. Controller profile setup stays in the Controller Explorer.

Settings

Language settings

Offline workspace indexing is safety-bounded and can be partial in unusually large or adversarial workspaces. Disk entries are limited to 1 MiB each, 1,000 files, 32 MiB of source, 250,000 RAPID tokens, and 50,000 derived symbols/definitions. Discovery accepts at most 256 roots and bounds each scan to 1,000 directories, 10,000 directory entries, 2,000 children per directory, and 1,000 supported files. Each scan also stops starting work after 64 MiB of source, 500,000 RAPID tokens, or 100,000 derived items. Files beyond those limits do not contribute workspace symbols; open editor documents are still indexed.

Semantic highlighting uses VS Code's editor.semanticHighlighting.enabled. The formatter uses the editor's tab size and spaces-versus-tabs settings. Configuration changes apply without restarting the extension.

Controller settings

Do not edit passwords into controller settings. The extension stores them only in SecretStorage.

Output and troubleshooting

Open View > Output and select the channel relevant to the workflow:

• ABB RAPID Pack Controller for connection, detection, sessions, and reconnect;
• ABB RAPID Pack Module Deployment for validation, mastership, build errors, and cleanup;
• ABB RAPID Pack Controller I/O Audit and ABB RAPID Pack Controller I/O Configuration for I/O mutations;
• ABB RAPID Pack Live Monitor and ABB RAPID Pack Live Controller Data for selected live resources;
• ABB RAPID Controller Debugging for pointers and breakpoints; and
• ABB RAPID Pack Language Server for offline language-service lifecycle.

Logs redact credentials, authorization headers, cookies, and sensitive bodies.

Connection fails

• Confirm Workspace Trust, profile selection, host, protocol, port, generation, username, and password.
• For multiple local VCs, confirm which unique port belongs to the intended controller.
• Verify the controller is fully started rather than in boot-server or restart state.
• Try the controller's IP address if hostname resolution is incorrect.
• Open the base URL in a browser to confirm that RWS is reachable and accepts the same UAS account.
• Check firewall, routing, proxy, controller communication options, and the selected network port.

TLS validation fails

Install or trust the controller certificate when possible. Disabling certificate validation permits impersonation and is intended only for a controlled development environment. Do not solve a production certificate issue by silently switching to HTTP.

Credentials fail after a controller restart

Wait until RobotWare is fully available. The extension accepts a replacement Digest nonce, clears obsolete session cookies, and performs bounded reconnect after an observed loss. If authentication still fails, disconnect, reconnect, and verify the selected profile's UAS credentials.

RAPID tasks or modules do not load

• Confirm the controller is not in boot-server mode and that its RobotWare release exposes the expected RWS task/module resources.
• Check the controller user's read permissions and installed options.
• Some RobotWare 6 controllers omit task activity metadata for system or semistatic tasks. The extension keeps those tasks available for browsing and module download while showing omitted activity as unavailable.
• If a controller response advertises more module text than it returns, the extension rejects the incomplete download and leaves the existing local file untouched.

A write is disabled or denied

Confirm all four extension gates: trusted workspace, Read & Write profile, enabled profile write/execute switch, and active connection-scoped write access. Then check UAS grants, operating mode, task/execution state, controller write access or mastership, and any signal Access Level. Manual-mode operations can also require RMMP, which the extension does not currently request.

On RobotWare 8, allow remote access from the FlexPendant before retrying. The extension registers itself as a remote Control Station with release-on-connection-loss, requests write access only for the guarded operation, and releases it afterward. For a confirmed Motors On or Start command, it enables Control Station motion control only for that guarded command scope. RobotWare 8 still requires a deliberate controller Reset after startup, operating-mode changes, and safety stops; if the Explorer reports Guard Stop, perform Reset from the FlexPendant/RobotStudio or a configured safe input. The extension does not bypass that controller safety requirement.

Deployment fails

Open ABB RAPID Pack Module Deployment. The output includes current language-server diagnostics, controller build-error details when available, the failing task/module, redacted ABB codes, and the cleanup result. Check syntax, task selection, execution state, controller write access or mastership, UAS grants, temporary File Service access, and load/unload support. RAPID execution is not restarted automatically.

Controller state or a watch is unknown or stale

Refresh the Explorer and inspect the Live Monitor status. Some controller variants omit fields or subscription events. The extension performs bounded reconciliation and selected-resource polling without interpreting an unavailable observation as stopped or safe.

Refresh did not preserve a local edit

This is the intended behavior of the manual Synchronize Workspace from Controller command: it replaces the synchronized local module files with controller copies and clears pending state. Use Git, commit, stash, or copy local edits before refreshing. Automatic synchronization after connection remains the non-destructive path for known pending files.

Known limitations

• Supported controller targets are IRC5 / RobotWare 6 / RWS 1.0 and OmniCore / RobotWare 7 or 8 / RWS 2.0. Capability and endpoint availability still vary by RobotWare release and installed options.
• Controller synchronization covers loaded RAPID modules and a generated SYSPAR/EIO.cfg snapshot containing signal names, types, and device names where RWS reports them. It is not a complete controller backup, exact CFG export, or every File Service object.
• Module endpoints return decoded text, so synchronized modules are normalized to UTF-8. Raw File Service transfers preserve supported source bytes.
• Deployment has no automatic rollback and never restarts RAPID execution.
• RAPID value writes reject symbolic atoms, arbitrary expressions, ragged arrays, and complex shapes that cannot be validated.
• Monitoring subscribes only to selected resources and may fall back to bounded read-only polling.
• I/O signal creation does not discover devices or choose Device Mapping automatically.
• Only the normal controller warm start is exposed; other restart modes and shutdown are not.
• RMMP acquisition for Manual-mode mutations is not implemented.
• IRC5 RWS 1.0 does not expose a supported breakpoint-removal operation; motion-pointer and breakpoint availability can also vary by task and RobotWare state.
• The offline language server does not compile against a specific RobotWare version or installed option set. RobotStudio or controller verification remains required before deployment.

Privacy, security, and safety

All language processing stays on your machine. The extension contains no telemetry and communicates with its bundled language server over local IPC. Controller connectivity remains in the VS Code extension host; credentials, cookies, sessions, and controller clients are not exposed to the language server.

Controller actions require a trusted workspace. In an untrusted workspace, offline language features remain active, but connections, live reads, file synchronization, and mutations are disabled. HTTPS is the default. HTTP and disabled certificate validation are explicit insecure opt-downs.

Policy gates, state checks, mastership handling, and confirmations reduce accidental operations. They do not establish or guarantee physical safety. Controller, robot, tooling, workcell, and personnel safety remain the user's responsibility. Follow ABB documentation and site-specific safety procedures before enabling or invoking any controller mutation.

See the controller security review for threat boundaries and residual risks.

File icons

RAPID files receive a light/dark language icon when the active file-icon theme supports language fallbacks. Select ABB RAPID Pack File Icons through Preferences: File Icon Theme for dedicated icons that distinguish .mod, .modx, .sys, .sysx, and .prg.

License

ABB RAPID Pack is available under the MIT License. Third-party runtime notices are listed in THIRD_PARTY_NOTICES.md.