Thinfinity VirtualUI features

Any Web Browser

Thinfinity VirtualUI enables Windows applications to run natively on any web browser by virtualizing the application’s interface and streaming it directly to the client. This allows users to access full-featured Windows applications through popular web browsers such as Chrome, Firefox, Safari, and Edge—on any device.

All Coding Languages

Thinfinity VirtualUI offers seamless integration with a diverse array of coding languages, allowing developers to modernize and web-enable their applications without the need for complete rewrites. Supported coding languages include: C++, C#, Delphi, Lazarus, Microsoft (MS) Access, Microsoft Foundation Class (MFC), Python, QT, VB.NET, Visual Basic 6 (VB6), Visual Fox Pro 9, Visual Fox Pro, Windev, XBase++, and Windows Presentation Foundation (WPF).

If your Language is not listed, contact us.

App Level Virtualization

App-Level Virtualization Thinfinity VirtualUI

Unlike traditional virtualization solutions that virtualize entire desktops or operating systems, Thinfinity VirtualUI virtualizes at the application level. This means that developers gain more granular control over how the application interacts with the environment. Instead of virtualizing a full machine, Thinfinity isolates and manages the application itself, providing more flexibility and extending the possibilities for application modernization and integration into modern workflows.

Registry Virtualization

Thinfinity VirtualUI supports registry virtualization, enabling developers to securely store user information within the Windows registry while running applications virtually. This allows registry entries to be managed efficiently, whether in a shared environment for multiple users or as private entries linked to individual sessions.

Flexible Storage

Registry entries can be redirected to shared or private entries depending on the application’s authentication system, ensuring proper access control and data separation based on user roles or sessions.

User-Specific Customization

The virtualized registry allows applications to dynamically adjust settings and behavior based on the authenticated user, enhancing personalization and ensuring a tailored experience for each user session.

Secure Environment

By virtualizing registry access, Thinfinity VirtualUI ensures that sensitive information, such as user preferences or application settings, remains secure during the virtualization process.

This registry virtualization feature streamlines the management of user data and application settings, providing both security and flexibility in virtualized environments.

File System Virtualization

Thinfinity VirtualUI includes file system virtualization, creating a secure, controlled environment for virtualized Windows applications. By managing access permissions at the application level, developers can restrict or allow access to specific folders based on the user’s authentication system.

Controlled Access

VirtualUI grants precise access to predefined application folders, ensuring that only authorized users or sessions can read, write, or modify files within these secure directories.

Authentication-Based Redirection

Depending on the application’s authentication system, file access can be dynamically redirected to private or shared folders, enabling flexible and personalized storage configurations while maintaining a high level of security.

Private Folders

The file system can also provide private folders for users, isolating each session’s data securely. This ensures that user-specific files are kept confidential and inaccessible to other users, further enhancing security.

This feature helps maintain a secure virtualized environment while facilitating user-specific file management and application settings.

Classes / Properties / Events

Unlike traditional virtualization options, Thinfinity VirtualUI integrates deeply at the application level, enabling developers to interact with their applications on a granular scale. By providing access to Classes, Properties, and Events, Thinfinity allows developers to interact directly with the application’s internal state and behavior, making it possible to implement features like error handling, browser interactions, and responsive design adjustments in real time. This low-level interaction gives developers precise control over how their virtualized applications respond to user inputs and system changes, offering a more dynamic and adaptive virtualization environment compared to conventional solutions.

→ Cross-Architecture Support

Thinfinity VirtualUI enables developers to run 32-bit applications seamlessly on 64-bit Windows servers without modification. This capability allows businesses to modernize and virtualize older software applications while leveraging the performance and scalability of 64-bit server environments.

Seamless Compatibility

Thinfinity VirtualUI bridges the compatibility gap between 32-bit applications and 64-bit Windows servers, ensuring that legacy applications continue to function smoothly in modern environments.

Enhanced Performance

By hosting 32-bit applications on powerful 64-bit servers, organizations can benefit from improved processing power and memory utilization, boosting application performance.

No Recompiling Required

Developers do not need to recompile or modify the original 32-bit codebase. VirtualUI handles the environment, allowing the application to run as intended.

This feature provides a cost-effective way to modernize legacy applications without the need for extensive code refactoring or redevelopment, enabling organizations to maintain their critical software solutions while taking advantage of modern server infrastructures.

→ BrowserInfo

Thinfinity VirtualUI’s BrowserInfo feature allows developers to retrieve specific data about the browser and the device used by the end user.

Device Detection

Using BrowserInfo, developers can identify whether the user is accessing the application from a mobile device, tablet, or desktop. This allows them to tailor the application interface, such as delivering a mobile-adapted version for smaller screens or touch-friendly interactions.

User-Centric Customization

By gathering detailed browser information, developers can offer a more personalized user experience, adapting features and interface elements based on the device’s capabilities, enhancing usability across platforms.

Responsive Design

The browser’s dimensions can be detected dynamically, enabling responsive adjustments to the layout, ensuring the application performs optimally regardless of the screen size or device.

→ HTMLDoc.ImportHTML

Thinfinity VirtualUI allows advanced integration of web applications through the HTMLDoc.ImportHTML function, enabling developers to import HTML content directly from an application.

Web App Integration

Seamlessly incorporate HTML content from web applications into virtualized Windows apps, allowing for dynamic and interactive elements to be imported and displayed natively within the app.

Streamlined Workflow

Import HTML without complex development, offering users enriched interfaces and web-driven functionalities directly within their virtualized application environments.

Modernize Legacy Apps

Enhance legacy Windows applications by embedding real-time HTML components, creating a more fluid integration between web-based tools and traditional software.

→ OnClose

Thinfinity VirtualUI provides the OnClose event, which is triggered during any abnormal closure of the application, such as when the browser is closed unexpectedly, the remote PC shuts down, or a communication timeout occurs.

User Status Detection

This event enables developers to detect if a user has disconnected due to browser closure, network issues, or remote shutdown, providing critical insight into user activity.

Enhanced User Monitoring

Detect when a user is off or disconnected in real time, helping to maintain smoother operations and prevent data loss or incomplete processes.

Session Handling

With OnClose, applications can react to unexpected session terminations, ensuring that data integrity is maintained and that appropriate actions (such as logging or session cleanup) are triggered automatically.

→ OnBrowseResize

Thinfinity VirtualUI triggers the OnBrowseResize event whenever the browser window is resized by the user.

Responsive Design

This event allows developers to adjust the layout of their application dynamically, making the application responsive to different browser window sizes.

Optimized User Experience

Automatically scale and reformat your application’s UI based on real-time browser resizing, providing a consistent and user-friendly experience across all screen sizes.

Adaptive UI

With OnBrowseResize, applications can adapt their user interfaces, ensuring a seamless experience across devices, whether on desktops, tablets, or mobile devices.

→ UnReceivedMessage

Thinfinity VirtualUI’s UnReceivedMessage event is triggered when a message is received by the browser page.

Dynamic Integration

This event allows your application to dynamically receive data while integrated within an iframe on another page.

Cross-Page Integration

Ideal for scenarios where your app needs to exchange information with external web pages, ensuring that your application stays in sync even within embedded environments like iframes.

Real-Time Communication

Utilize UnReceivedMessage to process and react to incoming messages, enabling seamless real-time interaction between your application and its hosting environment.

→ OnError

Thinfinity VirtualUI’s OnError event is triggered whenever an unexpected runtime error occurs during the application’s execution.

Error Notifications

Use the OnError event to capture and log runtime errors. You can configure your server to send automatic alerts or notifications, such as sending an email to administrators, whenever an unexpected error happens.

Enhanced Debugging

Capture detailed error logs and diagnostics to improve the robustness and reliability of your virtualized applications.

Automated Error Handling

This event enables real-time error tracking, allowing developers to respond quickly and prevent potential downtime by taking corrective actions immediately.

→ Open Link Dialog

Thinfinity VirtualUI’s Open Link Dialog feature allows virtualized applications to open any URL natively in the end user’s browser. This capability simplifies the user experience by seamlessly redirecting external links or web resources from the application to the user’s local browser, providing an intuitive, fluid interaction between the virtualized environment and web resources without additional complexity.

→ Shell.Execute

Thinfinity VirtualUI’s Shell.Execute feature is designed to optimize the user experience when dealing with complex applications that consist of multiple executable files or modules. For industries such as manufacturing, ERP management, SCADA systems, and pharmaceutical software—where large software suites are common—Shell.Execute allows seamless management by launching additional executables directly from the main portal in a web browser. This streamlines workflows by enabling developers to virtualize and manage the entire suite of applications under a single web interface.

For instance, if your ERP system comprises multiple tools (e.g., accounting, inventory, and HR modules), each traditionally launched via different executables, Shell.Execute allows you to call these modules as individual web apps without needing additional configuration on the client side. It ensures that all applications work together cohesively while keeping the complexity hidden from the user. This solution enables an efficient, native-feeling user experience, particularly for environments requiring multiple, specialized tools working in tandem, such as enterprise software, process automation systems, and lab management platforms.

Advanced File Transfer

Direct Upload to the Application

Thinfinity VirtualUI’s direct upload feature enables seamless file transfers into virtualized Windows applications running within a browser. By utilizing proprietary virtual channels, Thinfinity circumvents traditional browser limitations, creating a high-performance, native-like experience for file uploads.

Virtual Channel Implementation

Thinfinity establishes dedicated virtual channels between the client browser and the virtualized application. These channels allow for efficient, low-latency data flow, closely mirroring the behavior of native desktop applications and ensuring real-time file uploads.

Session Isolation and Device Access

Each upload session is securely isolated and directly connected to the user’s application session. Users can easily upload files and browse their local devices for file selection, bypassing the need for intermediate storage and maintaining optimal security and performance efficiency.

Direct Download to the End User Browser

Thinfinity VirtualUI enables the direct download of files from virtualized Windows applications straight to the user’s browser. By leveraging virtual channels, Thinfinity bypasses the native “Save File” actions, which would typically store files on the server where the application is installed, and instead redirects them to the user’s local environment.

Virtual Channel Implementation

Thinfinity establishes virtual channels that connect the virtualized application directly to the user’s browser. This allows the application to route file downloads to the user’s device, bypassing server storage, and enabling seamless integration between the virtualized application and the user’s local file system.

Download Redirection

All download-related operations, such as saving files or exporting data from the virtualized application, are automatically redirected to the user’s browser. This eliminates the need for manual intervention and ensures that files are downloaded locally rather than being saved on the server, enhancing both usability and data control.

Drag and Drop Upload

Thinfinity VirtualUI allows developers to create a native canvas space within their Windows applications, where users can drop files for direct upload into the virtualized application. This enhances user interaction and improves the workflow for applications requiring file inputs.

Seamless Integration

Dragging and dropping files onto a native canvas inside the virtualized application triggers an instant upload, maintaining a native application feel.

Versatile Application

This drag-and-drop functionality is suitable for use cases such as document management, media uploads, or any application requiring direct file input.

Efficient File Transfer

Leveraging Thinfinity’s high-performance virtual channels, the dropped files are directly uploaded with minimal latency and without extra steps.

Printing & Peripherals and UX

Clientless Print Redirection

Thinfinity VirtualUI includes a clientless print redirection feature that enables users to print directly from a virtualized Windows application to their local printers, without the need for additional software installations on the client device.

Virtual Printer Integration

Thinfinity VirtualUI provides a built-in virtual printer within the application, which captures any print job generated by the virtualized app and redirects it to the end user’s browser.

Clientless Operation

This functionality eliminates the need for users to install print drivers or client software, making it an ideal solution for secure and flexible printing across different platforms.

Seamless Local Printing

Once the print job reaches the browser, it can be sent directly to any local printer connected to the user’s device, ensuring a smooth and intuitive printing experience.

POS and Label Printing

Thinfinity VirtualUI offers robust printer redirection capabilities designed specifically for POS applications or ERP systems that require frequent printing, such as POS tickets or labels. The system supports both agent-based and network-agent-based printing, providing seamless mapping between the virtualized application and any printer connected to the user’s local machine or network.

Agent-Based Printing

Thinfinity VirtualUI allows the virtualized application to connect directly to printers attached to the user’s machine via an agent, ensuring a reliable, local-like printing experience.

Local-Like Experience

This functionality ensures that POS tickets or labels are printed as if from a local desktop application, providing fast, accurate, and efficient print operations, essential for POS systems and label generation.

Network Printer Integration

The network agent allows users to map their virtual applications to any network printer, regardless of location, making it perfect for environments that rely on shared printing resources.

RAW Printing

For specialized printers and legacy systems, Thinfinity VirtualUI provides support for RAW printing. This feature enables direct transmission of RAW print jobs from the virtualized application to the user’s printer, preserving the native experience required for specialized applications.

Direct Communication

Thinfinity VirtualUI sends the RAW print job directly to the printer, bypassing any intermediate processing that could interfere with the print format, ensuring that specific instructions or commands unique to specialized printers are executed accurately.

Support for Specialized Applications

Ideal for environments with specific printing needs, such as industrial, medical, or legacy systems, this feature guarantees compatibility and reliability, maintaining the integrity of print jobs regardless of complexity.

Native Experience

By allowing applications to communicate natively with the printer, Thinfinity ensures that legacy systems or applications requiring specialized print functions deliver outputs as they would in a traditional local environment.

Bulk Printing

Thinfinity VirtualUI’s bulk printing feature is designed for applications that require the ability to handle extensive print jobs efficiently, such as in point-of-sale (POS) systems, logistics, or financial services.

High-Volume Printing

Thinfinity VirtualUI ensures that virtualized applications can handle large print queues without performance bottlenecks. Applications that need to print multiple documents—such as shipping labels, customer invoices, or transaction receipts—benefit from the platform’s ability to manage bulk printing tasks smoothly and reliably.

Optimized Print Queues

By optimizing how print jobs are sent and processed, Thinfinity VirtualUI guarantees that extensive print jobs are queued and printed with minimal latency, creating a streamlined experience even for large-scale operations.

Seamless Workflow Integration

Whether it’s a retail POS generating numerous receipts, a warehouse printing hundreds of labels, or a financial institution creating bulk statements, Thinfinity’s bulk printing capabilities allow businesses to maintain high productivity levels, minimizing downtime caused by print delays.

Launch Multiprint

Thinfinity VirtualUI’s Multiprint feature enables advanced multi-printer support, allowing users to send print jobs to multiple printers simultaneously from a single virtualized application.

Multi-Printer Support

Thinfinity’s Multiprint tool allows users to direct a single print job to multiple printers, enhancing operational efficiency in environments that require large-scale or distributed printing.

Versatile Printing Capabilities

This feature is particularly beneficial in industries that demand high-volume or geographically dispersed printing, such as manufacturing, distribution, or retail, where multiple print outputs are necessary at once.

Purpose

Ideal for organizations with complex printing needs—such as logistics companies, retail chains, or large offices—where documents, labels, or receipts need to be printed across various locations, ensuring consistent and synchronized output.

Peripherals

Thinfinity VirtualUI supports the seamless integration of various peripherals such as barcode scanners, USB printers, and other specialized hardware within virtualized applications, enabling a native-like experience for end users.

Barcode Scanners

Thinfinity allows barcode scanners to be directly connected to virtualized applications, enabling businesses to use them in real-time for inventory management, retail operations, or warehouse workflows. Data is transmitted as though the device is physically connected to the application.

USB Printers

With Thinfinity VirtualUI, users can print directly from their virtual applications to any connected USB printer. This allows businesses to streamline their workflows for printing receipts, labels, or tickets without sacrificing local performance.

Native Clipboard Redirection

Thinfinity VirtualUI enables seamless text and rich text clipboard redirection, allowing users to copy and paste data between their local machines and virtualized Windows applications effortlessly.

Text Transfer

Easily copy plain text or rich text, including formatting like fonts and colors, between local devices and virtualized apps in real-time, preserving formatting integrity.

Boost Productivity

Users experience a smooth and natural workflow, mirroring local desktop interactions, ideal for content-heavy tasks in sectors like finance, education, and content management.

This native clipboard redirection enhances productivity by offering a truly integrated, local-like experience within browser-based virtualized environments.

Advanced Integration

iFrame

Thinfinity VirtualUI supports embedding virtualized Windows applications directly into an iFrame, making it an ideal solution for integrating legacy or virtualized applications within modern web portals. This allows developers and Independent Software Vendors (ISVs) to seamlessly blend Windows applications with existing web-based user experiences or modernized front-end systems.

The iFrame integration helps unify the user experience by embedding virtualized applications into broader ecosystems, where other native web components already exist. For organizations that have migrated their user interface to web technologies, such as React or Angular, this feature allows the Windows application to coexist within a web application, enhancing consistency without the need for complete refactoring. It’s particularly suitable for ISVs looking to extend legacy desktop apps into multi-functional web platforms, ensuring a cohesive and modernized experience for end-users.

JavaScript Remote Objects (jsRO)

Thinfinity VirtualUI’s JavaScript Remote Objects (jsRO) feature enables seamless integration between virtualized Windows applications and modern web technologies. jsRO allows developers to expose methods and properties from the server-side application as JavaScript objects, enabling direct interaction with the client-side browser environment. This capability is particularly useful when modernizing legacy applications and creating a cohesive hybrid interface between desktop and web applications.

jsRO opens up a world of possibilities for extending the functionality of virtualized applications, making it easier to integrate them with modern web technologies like React, Vue.js, or Angular, without needing to rewrite the backend code. This integration helps create a modern and interactive user interface while preserving the core logic of the legacy application.

jsRO graphic

Bidirectional Communication

Facilitated by JavaScript Remote Objects (jsRO), creates a live connection between virtualized Windows applications and the client-side JavaScript environment. This real-time link enables seamless data and command exchanges between the server-side application and the user’s web browser.

bidirectional communication

Dynamic User Interfaces

This bidirectional connection makes it possible to create dynamic and interactive user interfaces that respond to both server-side events and client-side user actions. Web applications can trigger commands in the virtualized application, and the application can send updates back to the web interface, creating a smooth and responsive experience.

Real-Time Interaction

jsRO allows data to flow in both directions—between the virtualized application and the web browser HTML5 Component—ensuring that changes made in one environment are instantly reflected in the other. For instance, updates in the virtualized application can trigger immediate actions or updates in the new web interface.

Enhanced Integration

By establishing this live connection, developers can create highly interactive web interfaces that remain tightly integrated with the underlying logic of the virtualized Windows application, without needing to re-architect the entire backend.

Event Binding

This feature allows developers to bind server-side events to client-side JavaScript functions. This capability enables the creation of highly reactive user interfaces that respond to both user input and changes within the virtualized application.

Reactive Interfaces

When an event occurs in the server-side application, such as a data update or user action, it can automatically trigger a corresponding JavaScript function on the client-side. This ensures that the web interface remains up-to-date and reactive without the need for constant polling or manual refreshes.

Enhanced User Interaction

By leveraging event binding, developers can build more interactive and responsive applications that adjust and respond in real-time to user actions, server-side processing, or other triggers within the virtualized environment.

Seamless Synchronization

Developers can synchronize the behaviors of the virtualized application and the web interface by linking specific server-side events to custom JavaScript actions. This helps create a seamless and integrated user experience, where the web application responds dynamically to changes happening within the virtualized app.

Object Exposure

Thinfinity VirtualUI’s Object Exposure feature allows the server-side application to expose its internal objects as JavaScript objects that can be directly manipulated within the web browser. This capability greatly simplifies the integration of traditional Windows applications with modern web interfaces.

Seamless Integration

By exposing server-side objects as JavaScript objects, developers can leverage the power of JavaScript to manipulate these objects natively within the browser. This enables seamless interaction between the application’s logic and the web interface without the need for complex middleware.

Streamlined Development

Object exposure minimizes the need for extensive rework or refactoring when integrating legacy applications into web-based systems. By treating server-side objects as native JavaScript objects, developers can modernize applications without the overhead of extensive code rewriting, simplifying the process of adding modern web functionality to existing applications.

Direct Access

Developers gain direct access to server-side data and functions, allowing them to build richer, more dynamic web interfaces that react to the application’s internal state. This promotes a smoother, more unified experience between the virtualized application and the modern web environment.

Cookie Preferences
Privacy and Cookie Policies
Cybele Software implements specific policies to enhance your browsing experience while respecting your privacy. When you visit Cybele Software's website, the site uses cookies to personalize your experience. These small files remember your preferences and the details of your repeated visits, aligning closely with Cybele's Privacy Policy.

You have complete control over the cookies used during your visit:
- Accepting All Cookies: You can agree to the use of all cookies by clicking “Accept All.” This provides a smoother, more integrated experience.
- Customizing Cookie Settings: If you prefer to manage your preferences, you can click on "Cookie Settings." This allows you to give controlled consent by selecting which types of cookies you agree to activate.
- Opting Out: You also have the option to opt-out entirely from non-essential cookies. It's important to note that choosing this option might impact your experience on the website, potentially limiting certain functionalities and features.
These features ensure that you can tailor your browsing according to your personal preferences and privacy concerns.