Study guide
8.3 Automation in Virtual Environments & UiPath Remote Runtime
UiPath Automation Developer Professional UiPath-ADPv1
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Exam Overview & Blueprint Map
1.1 About the UiPath-ADPv1 Exam: Format, Fees & Policies 1.2 The Exam Topics Mapped to This Guide & a Study Plan
2 Chapter 2: REFramework Architecture & State Dynamics
2.1 State Machine Architecture & The Four Core States 2.2 Configuration Management: Settings, Constants, and Assets 2.3 Transaction Types & The Dispatcher vs. Performer Architecture 2.4 Adapting REFramework: Tabular Data, Collections & Linear Processes
3 Chapter 3: REFramework Exception Handling & Recovery
3.1 BusinessRuleException vs. System.Exception Handling Patterns 3.2 Retry Mechanisms: Queue Retries vs. REFramework MaxRetryNumber 3.3 Consecutive System Exceptions & Graceful Process Termination
4 Chapter 4: State Machines, Custom Log Fields & REFramework Testing
4.1 Building State Machine Projects in Studio 4.2 Logging Levels, Robot Logs & Custom Log Fields in REFramework 4.3 Testing a REFramework Project With and Without Orchestrator Queues
5 Chapter 5: LINQ Queries & DataTable Operations
5.1 LINQ Essentials for Collections & Filtering 5.2 Advanced DataTable Querying with LINQ 5.3 In-Memory DataTable Transformations & Column Operations
6 Chapter 6: Regex, DateTime, JSON & Invoke Activities
6.1 Regular Expressions & Text Parsing for Automation 6.2 DateTime Formatting, Timezone Conversions & TimeSpan Calculations 6.3 JSON Parsing, JSONPath & Serialization with Newtonsoft.Json 6.4 Invoke Method & Invoke Code Activities 6.5 Data Referencing in Invokes: DataTable, List & Dictionary Arguments
7 Chapter 7: Modern UI Automation & Unified Targeting
7.1 Modern Design Experience & The Unified Target Concept 7.2 Anchors, Relative Elements & UI Automation Activities 7.3 Dynamic Selectors, Variables & Wildcards in Selectors
8 Chapter 8: Object Repository, Computer Vision & Remote Runtime
8.1 Object Repository & UI Descriptor Libraries 8.2 AI Computer Vision for Unattended & Remote Interfaces 8.3 Automation in Virtual Environments & UiPath Remote Runtime
9 Chapter 9: Advanced UI Automation: Browser Modes, Agentic UI & macOS
9.1 Browser Automation with the WebDriver Protocol 9.2 Agentic UI Automation: ScreenPlay, Semantic Activities & Healing Agent 9.3 macOS Automation: Native Apps, Office Apps & AppleScript
10 Chapter 10: Advanced Control Flow & Exception Architecture
10.1 Flowcharts, Sequences & Parallel Control Flow Patterns 10.2 Global Exception Handler Architecture & ErrorAction Directives 10.3 TryCatch, Retry Scope & Custom Exception Architectures
11 Chapter 11: Orchestrator Queues & Transaction Management
11.1 Queue Architecture, SpecificContent & Transaction Lifecycles 11.2 Queue Items SLA, Postpone, Deadlines & Priority Scheduling 11.3 Bulk Operations, Transaction Status Updates & Queue Triggers
12 Chapter 12: Orchestrator Tenant & Folder Entities
12.1 Asset Types, Per-Robot Assets & External Credential Stores 12.2 Modern Folder Hierarchy, User/Robot Assignment & Permissions 12.3 Storage Buckets, Webhooks & Environment Promotion 12.4 Orchestrator Tags: Labels, Properties & Governance
13 Chapter 13: Unattended Execution, API Triggers & Cloud Robots
13.1 Unattended Job Execution: Folders, Priorities, Background vs. Foreground & Runtimes 13.2 API Triggers: Starting Jobs from External Systems over HTTP 13.3 Serverless and Cloud VM Robots: Cloud-Hosted Execution Options
14 Chapter 14: Monitoring, Recording & Solutions Management
14.1 Orchestrator Monitoring, Trigger Alerts & Job Health 14.2 Job and Transaction Recording: Troubleshooting Faulted Unattended Jobs 14.3 Solutions Management: Packaging and Deploying Automations with Their Resources
15 Chapter 15: Debugging, Remote Debugging & Profiling
15.1 Studio Debugging Tools: Breakpoints, Panels & Execution Control 15.2 Remote Debugging: Remote Machine and Unattended Robot Connections 15.3 Profile Execution: Finding Performance Bottlenecks in Studio
16 Chapter 16: RPA Testing & Test Suite
16.1 UiPath Test Suite Overview, Test Cases & Given-When-Then Structure 16.2 Data-Driven Testing, Test Verification Activities & Mock Activities 16.3 CI/CD Pipelines with uipcli & Test Manager Traceability
17 Chapter 17: Long-Running Workflows, Action Center & Apps
17.1 Long-Running Workflows: Persistence, Suspend and Resume 17.2 Action Center & Human-in-the-Loop Orchestration 17.3 UiPath Apps: Action Apps, Automations & Integration Service
18 Chapter 18: Trigger-Based Attended Automation & Callouts
18.1 Trigger-Based Attended Automation: Forms, Triggers & Global Variables 18.2 Running Local Triggers & the Event Inspection Tool 18.3 Callouts & Forms for Attended Guidance
19 Chapter 19: UiPath Assistant & Robot Sessions
19.1 UiPath Assistant: Automations, Reminders, Widgets & Configuration 19.2 Robot Session (Picture in Picture): Child Session vs. Virtual Desktop
20 Chapter 20: Autopilot for Developers & Autopilot for Everyone
20.1 Autopilot for Developers: AI Assistance in Studio and Studio Web 20.2 Autopilot for Everyone: Chat, Automations & Clipboard AI
21 Chapter 21: API Automation & Integration Service
21.1 Integration Service: Connectors, Connections & Connector Activities 21.2 API Workflows in Studio Web 21.3 HTTP Requests: Web APIs, the Orchestrator API & Connector Requests 21.4 Connector Builder: Custom Integration Service Connectors 21.5 Integration Service Event Triggers: Connected and Disconnected 21.6 GenAI Activities: Generative AI Inside Workflows
22 Chapter 22: Data Service, Context Grounding & Coded Workflows
22.1 Data Fabric (Data Service) Entities: Modeling Business Data 22.2 Data Fabric Activities and the Platform Connector 22.3 Context Grounding: Retrieval-Augmented Generation with Company Data 22.4 Coded Automations: Structure, Arguments & Invoking Workflows 22.5 Coded Automation Services: Orchestrator, UI Automation, Microsoft 365 & Custom Services
23 Chapter 23: Integrated Scenario Practice
23.1 Integrated Scenario Practice: Designing an End-to-End Solution
8.3 Automation in Virtual Environments & UiPath Remote Runtime
Key Takeaways Explain This Topic AI
Virtual desktops (Citrix, VMware Horizon, Microsoft RDP and RemoteApp, Amazon WorkSpaces) send only pixels to the client unless UiPath Remote Runtime is installed on the remote machine.
Remote Runtime reads the remote application's UI tree and passes it to the matching UiPath extension on the client, so selectors are generated natively over the protocol's virtual channel.
Install it with UiPathRemoteRuntime.msi ; its Task Scheduler entry starts UiPathRemoteRuntime.exe at every user login.
Remote Runtime must be at least the newest UIAutomation package version in your projects, and it is backward compatible with older packages.
Citrix 7 2109 and later block custom virtual channels by default, so the UiPath channel must be added to the allow list policy.
Last updated: September 2026
8.3 Automation in Virtual Environments & UiPath Remote Runtime
Core Concept: In enterprise virtualization environments—including Citrix Virtual Apps and Desktops , VMware Horizon , Windows Virtual Desktop / Azure Virtual Desktop (AVD) , and standard Remote Desktop Protocol (RDP) —target business applications execute on remote servers while only graphical display updates are transmitted back to client endpoints. UiPath Remote Runtime is an administrative component installed on the remote server that acts as an in-session automation proxy. By communicating directly with local UiPath Studio and Robot instances over the native virtual channel of the remote desktop protocol, Remote Runtime enables 100% native selector generation, deep UI tree inspection via UI Explorer, and background execution in remote sessions.
Virtual desktop infrastructure (VDI) is ubiquitous across regulated industries such as banking, insurance, and healthcare. VDI enables centralized data protection, regulatory isolation, and remote worker mobility. However, from a traditional robotic automation perspective, VDI environments present a formidable barrier: the automation robot running on the developer workstation or local runner machine cannot inspect the internal memory, process trees, or accessibility APIs of applications running inside the virtual desktop session. Without dedicated architectural intervention, the remote session remains an impenetrable "black box" of pixels.
1. The Challenges of Automating Virtual Environments
When automating over virtual environments without native integration tools, robots are restricted to client-side visual automation (Classic Image Matching, OCR, or Computer Vision). While Computer Vision provides excellent visual targeting, visual-only automation carries distinct operational limitations in high-volume unattended production:
Screen Resolution and DPI Sensitivity: If a remote desktop session initializes with an unexpected resolution (e.g., 1280x720 instead of 1920x1080) or if the Windows display scaling differs between user sessions (e.g., 100% vs. 125%), pixel-based targeting can fail or require continuous recalibration.
Network Latency Jitter: Latency fluctuations across WAN connections can cause screen rendering delays. If a robot attempts to click a visual image before the remote frame buffer renders on the client display, race conditions and timeout exceptions occur.
Inability to Execute in Background: Pure visual automation requires the remote desktop window to remain open, maximized, in the foreground, and completely un-occluded on the client desktop. Minimizing or locking the local client window immediately halts image recognition.
No Access to Underlying Metadata: Visual techniques cannot query underlying DOM attributes, accessibility states, hidden form values, or native application properties that make automations robust.
2. UiPath Remote Runtime Architecture
UiPath Remote Runtime solves the VDI challenge by shifting element discovery and execution inside the remote session itself .
Architectural Components
The Remote Runtime architecture consists of three interconnected layers:
The Client Workstation (Local Host):
UiPath Studio / UiPath Robot: Executes the automation workflow.
UiPath.UIAutomation.Activities Package: The automation library generating and executing UI queries.
Local Protocol Extension: The matching UiPath extension installed on the client machine: UiPath Extension for Citrix , for Windows Remote Desktop and Apps , for VMware Horizon , or for Amazon WorkSpaces . It works with the local client software (such as Citrix Workspace app, VMware Horizon Client, or the Windows Remote Desktop client mstsc.exe ).
The Virtual Communication Channel:
Communication between the local client and the remote server does not rely on external TCP/IP network sockets or HTTP web services. Instead, it utilizes the native, encrypted Virtual Channel embedded within the virtualization protocol:
Citrix: ICA / HDX virtual channel.
VMware Horizon: VMware Horizon Virtual Channel.
Microsoft RDP / AVD: Remote Desktop Dynamic Virtual Channel (DVC).
Zero Port Security Advantage: Because communication multiplexes over the existing, authenticated VDI connection, organizations do not need to open any firewall ports (such as port 80, 443, or 8080) between client machines and the remote server.
The Remote Server / VDI Host:
UiPath Remote Runtime ( UiPathRemoteRuntime.exe ): Installed on the remote desktop host, Citrix server, or master VDI image. The installer adds a Task Scheduler entry so the process starts at every user login, for every user on the server.
Installed versions: All installed Remote Runtime versions are listed under %ProgramFiles(x86)%\UiPath\RemoteRuntime\packages\uipath .
Target Applications: Local software running on the remote server (e.g., SAP GUI, Oracle ERP, desktop CRM, web browsers). +-----------------------------------------------------------------------------------------+
- | REMOTE RUNTIME ARCHITECTURE |
- | |
- | [LOCAL CLIENT WORKSTATION] |
- | +-----------------------------------------------------------------------------------+ |
- | | UiPath Studio / UiPath Robot | |
- | | UiPath.UIAutomation.Activities Package | |
- | | Local Extension (Citrix Workspace / mstsc.exe / VMware Horizon Client) | |
- | +-----------------------------------------------------------------------------------+ |
- | │ |
- | ▼ |
- | [SECURE PROTOCOL VIRTUAL CHANNEL] |
- | - Citrix ICA / HDX Virtual Channel |
- | - Microsoft RDP Dynamic Virtual Channel (DVC) |
- | - VMware Horizon Virtual Channel |
- | (Multiplexed inside existing VDI session — No Open Firewall Ports) |
- | │ |
- | ▼ |
- | [REMOTE VDI / TERMINAL SERVER] |
- | +-----------------------------------------------------------------------------------+ |
- | | UiPath Remote Runtime (UiPathRemoteRuntime.exe, started at each user login) | |
- | | Installed versions listed under ...\UiPath\RemoteRuntime\packages\uipath | |
- | | | |
- | | Direct OS Accessibility Hooks: | |
- | | ├── Microsoft UI Automation (UIA) | |
- | | ├── Microsoft Active Accessibility (MSAA) | |
- | | ├── Java Access Bridge (JAB) | |
- | | └── Chrome / Edge Web Extensions | |
- | | | |
- | | Target Applications: [SAP WinGUI] [Java Client] [Chrome/Edge Web] [WPF Desktop] | |
- | +-----------------------------------------------------------------------------------+ |
- +-----------------------------------------------------------------------------------------+
- 3. Native Selector Extraction in Remote Sessions
When UiPath Remote Runtime is active, the entire development and execution experience transforms from flat-image guessing to full native targeting :
UI Explorer Over Virtual Desktops
A developer running UiPath Studio on their local machine can open UI Explorer , click Indicate Element , and move their cursor directly into the remote Citrix or RDP window. Instead of highlighting the entire remote desktop container as a single giant window, UI Explorer reaches across the virtual channel, inspects the remote operating system's accessibility tree, and highlights the precise button, input field, or table cell inside the remote application.
Full Selector Richness
The generated selectors are standard, rich, multi-attribute XML strings identical to those generated for local desktop applications:
The generated selectors use the same attributes you would see for a local application, because Remote Runtime reads the remote application's UI tree and passes it to the extension.
Developers can leverage:
Strict Selectors: Exact control IDs, automation names, and hierarchical tags.
Fuzzy Selectors: Matching attributes with configurable tolerance.
Wildcards ( * and ? ): Dynamic handling of shifting window titles or session IDs.
Relative Anchors: Relational visual and selector-based anchoring to static labels.
Input Methods in Remote Sessions
Because the element is identified inside the remote session, input modes such as Simulate and Window Messages can be used where the remote application supports them, instead of relying only on image clicks. That also reduces the dependence on the remote window being maximized and in focus.
4. Installation, Configuration & Compatibility Matrix
Deploying UiPath Remote Runtime requires coordination between the local developer/robot environment and the remote server infrastructure:
Installing Remote Runtime on the Server
Download UiPathRemoteRuntime.msi from the Customer Portal's Product Downloads or from the Automation Cloud Resource Center.
Install it with administrator rights on every Citrix application server, VMware Horizon machine, Remote Desktop machine, or Amazon WorkSpaces desktop that runs the target applications. A silent install looks like this: UiPathRemoteRuntime.msi ADDLOCAL=RemoteRuntime,RemoteRuntimeTask /quiet RemoteRuntimeTask adds the Task Scheduler entry that starts UiPathRemoteRuntime.exe at user login.
Log off from the Citrix, Horizon, RDP, or WorkSpaces session on the client machine and log back in so the change takes effect.
Enabling Local Extensions
On the local machine running Studio or the Robot:
Open Studio and navigate to Home > Tools > UiPath Extensions .
Install the specific extension matching your virtualization protocol: Citrix , Windows Remote Desktop and Apps , VMware Horizon , or Amazon WorkSpaces .
Restart the virtualization client software (e.g., Citrix Workspace or mstsc.exe ) to initialize the virtual channel driver.
The UIAutomation Dependency
Remote Runtime depends on the version of the UiPath.UIAutomation.Activities package, not on the Studio or Robot version. UiPath's rule is:
The Remote Runtime on the remote machine must be at the version of the latest UIAutomation package you use in your projects.
It is backward compatible , so older UIAutomation package versions keep working with a newer Remote Runtime.
- Project uses UIAutomation Remote Runtime on the server Result
- 24.10 24.10 or later Supported
- 23.10 24.10 Supported (backward compatible)
- 24.10 23.10 Mismatch: upgrade Remote Runtime
Important
When a project is upgraded to a newer UIAutomation package than the server's Remote Runtime, native selector generation over the virtual channel stops working correctly. UiPath lists this version mismatch as a named troubleshooting case. The fix is to upgrade Remote Runtime on the remote machines, or golden image, to at least the package version.
- 5. Enterprise Security, Governance & Troubleshooting
- High-Density and Multi-Session Environments
In enterprise environments where multiple human users and software robots share a single Windows Server via Remote Desktop Services (RDS) or Citrix Virtual Apps:
UiPath Remote Runtime operates in a multi-session architecture .
A master background coordinator manages virtual channel endpoints, while an isolated instance of UiPathRemoteRuntime.exe executes inside each individual Windows user session.
Process isolation is strictly maintained: a robot executing in Session 2 cannot view, intercept, or interact with applications running in Session 3, ensuring complete tenant and user data security.
Troubleshooting Virtual Channel Connectivity
If UI Explorer fails to extract native selectors and continues to select the entire remote desktop container as a single window, developers follow a standardized diagnostic checklist:
Check the Citrix virtual channel allow list:
Starting with Citrix Virtual Apps and Desktops 7 2109, custom virtual channels are blocked by default. Add the UiPath channel to the allow list policy: UIPCTX,C:\Program Files (x86)\UiPath\RemoteRuntime\UiPathRemoteRuntime.exe .
Verify Remote Runtime Process:
Open Windows Task Manager inside the remote VDI session and verify that UiPathRemoteRuntime.exe is running under the active user account.
Compare versions:
Confirm that the Remote Runtime version is at least the UIAutomation package version used by the project.
Check the client extension:
Confirm that the matching UiPath extension is installed on the client machine, and restart the client software after installing it.
Review Windows Event Logs:
Check the Application event log in Windows Event Viewer on both client and server for UiPathRemoteRuntime informational and error entries.