­

Virtuoso Documentation

Introduction To The Core Framework

Virtuoso is an application development workflow consisting of a Core Framework and a content library of components. The Core Framework is designed to accommodate the graphical development of an application, called the “host application”. After the application is designed graphically in the schematic editor, the design gets pushed to the host project, which is written in the language specific to that host, for example C#. Virtuoso handles creating and updating the host application according to the graphical design, essentially taking the graphical drawing and converting it to a corresponding application written in the host language.

Developers can develop their application entirely in the Virtuoso schematic, as may be the case if the developer doesn’t know the underlying host language. Or, the developer can just use the schematic as a starting point for an application design, using the convenience of the graphical design and graphical library, and then extend the design with additional custom functionality written in the host language. Subsequent changes to the schematic design can be made and pushed to the host application without affecting the host code you’ve added yourself.

The figure below shows this general workflow. Virtuoso is used to create a host. Components are graphically added to the schematic editor and configured, with ports connected as necessary. The Core Framework then emits the host code into the project needed to implement the schematic, using the optimum design pattern specific to the host language. For example, for a WPF C#/.NET host, the schematic editor will produce a design implemented with a Model-View-View Model design pattern as a starting point, and the developer can from there add and extend the functionality of the host directly in C# and XAML.

This workflow is ideal for applications that can be naturally expressed declaratively as a set of components logically interacting with other components in some way. The components may only represent code execution of business logic, or the components may represent controls which the user interacts with on the application view. In the Virtuoso host design paradigm, there is thus a schematic layer to the design and a visual layer. Each schematic component may or may not have a corresponding visual control on the view for user interaction. The logical component is represented as a model or view model, and the visual component is represented as a view bound to the corresponding view model. For a component that has a visual element, there is always a one-to-one correspondence between the component’s view on the visual layer and the component’s view model on the schematic layer.

In the example below, the schematic on the left shows a push button component and an LED component. The components have a boolean output port and a boolean input port, respectively. The ports are connected, representing that when the push button is pressed (true), the LED should be on. The view on the right shows the corresponding user interface. After placing the components on the schematic editor, making the connection between the ports, and pushing the updates to the host, the user simply needs to position the push button and LED view components, build the project, and run.

The Virtuoso Core Framework is built to be completely extensible to new host languages, new port types, and new components. You can easily write so-called “port metadata” classes which define new port types and defines the code to be emitted to represent a logical connection between that port type and any other port type, for a given host language. You can then write new components to use those port types, and then use Virtuoso to quickly create applications specific to your application domain using a schematic design flow.

The Virtuoso Core Framework is free for development purposes, as described in the Core Framework End User License Agreement. You may also deploy applications built using the Core Framework for commercial purposes, in some cases free and in other cases subject to a 5% royalty on gross revenue, also as described in the Core Framework EULA.

To summarize, the Core Framework is designed for both power and flexibility. It allows applications to be developed graphically without requiring knowledge of the host language, using an ever-expanding content library of components. Its extensible architecture allows you to customize and extend the functionality and components of Virtuoso to enhance existing ecosystems or forge new ones. It also allows any host application designed initially in the schematic with Virtuoso components to be further developed by host language developers using exactly the same application paradigm they are used to. Virtuoso components emitted to the host appear just like any normal class instance and can be interacted with in exactly the same way.