VIRTUOSO
FEATURES
Virtuoso is a set of several layered tools that form a state-of-the-art no-code platform engineering infrastructure that is designed to scale. The infrastructure consists of a “Core Framework”, host platforms, and host content.
LEARN MORE
The Core Framework at the heart of Virtuoso provides the No-Code visual programming environment. Here, “programming” is used somewhat loosely, as the visual design environment can be used to represent anything, not just software applications. The schematic editor provided by the Core Framework provides an environment where high-level capabilities that are boiled down to their simplest-to-understand concept can be simply dragged, dropped, and configured.
Virtuoso represents a no-code design environment targeted for a specific fully formed pro-code pipeline, including choice of programming language, integrated development environment, and so on. The schematic editor represents a specific “host” application and its corresponding pro-code workflow. Virtuoso is designed to extensibly support new host plugins, enabling new host environments to be augmented with a no-code workflow. This high-level workflow always flows down to the pro-code workflow, where the application can be extended professionally. With Virtuoso, developers can simultaneously write pro-code and no-code with no conflicts.
Once a host platform is supported, no-code content can be created by the community at scale that targets that host platform. The no-code content for each host platform thus represents infinite possibilities. Each component in the schematic editor’s toolbox provides a fully custom preview window and property editor designed specifically for that component, to provide the optimum experience for building an application with powerful capabilities and minimal cognitive load. Virtuoso represents the ultimate “golden highway” to software developer success. You can download content from the Montage digital marketplace, or create your own in-house self-serve no-code library to improve the maintainability of your operations.
Core Framework Features
The Core Framework currently comes out of the box with a C#/WPF .NET 6.0 host plugin available for use under the terms of the Core Framework EULA. This means you can create a C#/WPF host, drag and drop components, configure them and wire them up with each other for interaction, and the host plugin will translate your schematic design to a fully fledged C# application written with a Model-View-ViewModel design pattern. The output host emitted by the schematic editor can then be extended directly in C# and XAML, while still being able to modify at the schematic level.
The Core Framework is designed to support host plugins that allow schematic designs to be exported to any “host”. The “host” can be anything and is just an abstract concept of anything that meaningfully hosts multiple interconnected and configurable components and must be built. You can write a custom host plugin to streamline any operation that involves graphical design and export the graphical design in any way imaginable.
Anyone can write and share a host plugin to adapt it to any host language or adapt it to a completely proprietary output. The Core Framework can thus be used as a completely proprietary internal workflow improvement and automation tool.
We have several additional host platforms on our roadmap. If you have a need for a specific pro-code host platform, please let us know!
No-code components used in a particular host environment simply represent capabilities, and ways to interact with the capability in the host environment. A component can also be a host of internal components for a different host platform. This makes no-code orchestration of interoperable capabilities developed using different technologies possible. For example, you may want to add an Unreal Engine immersive 3D scene to a traditional C# WPF desktop application or host an embedded software application. With Virtuoso, seamless interoperability of complex hierarchical systems and technologies becomes possible.
Not only is the host platform extensible as a plugin, but components and port types are also completely extensible. You can use the framework conventions to write new components, define new port types, and completely redefine or extend the translation of port connections. You can easily create a new port type for C# hosts and define what it means for that port type to be connected to any other port type. You can easily create new components that then use any port types in the Virtuoso ecosystem. Port definitions provide the no-code connective tissue that enables interoperability between no-code components. From there, no-code components represent powerful, composable, easily configurable capabilities.
The core framework itself consists entirely of Montage Packages available on the public Montage package feed, and all extensions, including host plugins, component metadata, port metadata, and host components, are also available on the feed. New functionality provided by the community will be continually available, and you can also easily create and publish your own extensions of Virtuoso packages which integrate directly into the framework and are accessible on the Marketplace.
Virtuoso is built on the Montage digital ecosystem backbone, which provides modularity, discoverability, and orchestration that is critical for platform engineering. Most package management systems are homogeneous package management systems, meaning all packages are designed to be installed to specific project types (a single “Installation Target” type, in the Montage vernacular). Montage is a heterogeneous dependency management system, meaning anything can be defined as a package and referenced as a package dependency, including software installations. When Montage Activities are installed, everything needed for that Activity to work is installed, guaranteeing portability of the Activity. When you are sharing an Activity on Montage you can specify not only what needs to be inside a project, but also what needs to be installed on the computer or copied to the file system to ensure your Activity will be usable. This removes frustration and setup time on the user’s part and is a great way to manage build archives. Composite example projects containing references to packages from many merchants can be shared, and the Activity user can effortlessly pay all licensing fees to all merchants in a single step. Montage Activity Sharing takes collaboration to the next level.
The ultimate “Golden Highway” for efficient, friction less platform engineering is paved with end-to-end orchestration. Virtuoso and Montage together provide unparalleled platform engineering power.
Embedded Toolkit Features
The Embedded Toolkit is designed to host embedded software in the Virtuoso no-code environment, creating the Golden Highway for hardware-independent development for embedded systems. The Embedded Toolkit includes fully formed embedded software target templates that are ready to be dragged and dropped and easily customized for any embedded application.
Virtuoso allows powerful embedded systems virtualizations to be created in Microsoft Visual Studio 2022. Your embedded software code cross-compiles in both Visual Studio and your native toolset that compiles to your actual target. Write and debug your application code in Visual Studio, then simply compile and run on target when needed.
The Virtuoso Embedded Toolkit provides support for all common embedded systems peripherals and I/O, including general purpose digital I/O, analog I/O, interrupts, UART, SPI, I2C, I2S, graphical displays, non-volatile memory, and more. You can access these peripherals in the no-code library, connecting your I/O to virtual and physical hardware to compose your ideal embedded system virtualization environment.
With the QuickDAQ.mikroBUS, you can effortlessly connect your virtual microprocessor to access real-world embedded peripherals. The QuickDAQ.mikroBUS provides no-code access to three mikroBUS slots, and each slot can be configured to use whatever peripherals you like. The QuickDAQ.mikroBUS, together with the virtual microprocessors, creates an incredibly powerful platform to quickly, cheaply, and easily build an effective custom embedded software development workflow.