Virtuoso is built entirely of modular and discoverable Montage packages, from the Core Framework, to host plugins, to host content. Thus the scalability of Virtuoso is multifaceted, as it scales to new pro-code host environments, like C#, Python, and Java, and within each of those host environments it scales with unlimited content. And it not only scales with with new content being added, but it scales with composable content. That is, content that can interact with other content with which neither content has no prior knowledge of. This is made possible through the separation of two clearly distinct Virtuoso package types: "port" packages and "component" packages.

Virtuoso port packages are Montage packages that define no-code port interfaces. In our prevous example, the momentary pushbutton and the LED both must somehow "agree" on how to share boolean state information: how one component can logically drive a boolean value, how another component can receive a boolean value, and how those two interfaces connect in pro-code. These two components could come from completely different packages, in which case this design would represent three different packages: a port package that defines boolean interfaces, a component package that provides a momentary pushbutton, and a component package that provides an LED.

In the above image, two port definitions are used: a booelan driver port and a boolean receiver port. Each port defintion provides a default visual style indicating how the port should look by default. When a component author instantiates a port on their component, the default visual style is applied to the port. This saves the component author time, and also helps provide consistency in the look of the ports. Thus, all boolean ports are red, and output boolean ports have an arrow that points outward while input boolean ports have an arrow that points inward.

However, component authors are free to override the default style and design port instances hosted by their components to look however the component author likes. In the example below, the virtual evaluation board has boolean input D7 and boolean output B1 located along the top of the board, close to the physical I/O on the board. In this case, default styles for both the component and its ports were overriden to create this. Virtuoso is designed to provide a state-of-the-art, powerful schematic editor that enables content creators to present their abstractions exactly like they want.

The Virtuoso.Port.DotNet.Standard package introduces the boolean interface as well as numerous other new interfacing abstract concepts to the Virtuoso ecosystem. Once a no-code port interface is defined for a Virtuoso host platform, the entire host platform ecosystem can make content that uses these port definitions. And as we will see, these interfaces can be very sophisticated.

Port packages deliver content that is different from component packages. Port packages typically provide a single assembly that is installed to the host application that defines pro-code classes that are used to facilitate interoperability. There is no limitation on what can go into the port package assembly, and typically these assemblies contain substantial code bases. The assembly typically provides data classes containing the data that is exchanged between interfaces, as well as service interface defintions and service implementations. The specifics of what a port represents and how it is implemented is completely up to the developer's discretion. Port interfaces are easily designed by pro-coders familiar with the associated host environment. Port design is a low learning curve, but actually implementing a few ports is needed to fully understand the paradigm and the power that ports represent in scaling out ecosystems..

In addition to the pro-code classes each port provides in the installed assembly, port definitions also provide code snippets that are applied to components that expose port instances, as well as code snippets that are applied to the end application. This is an important point: port authors provide no-code design automation for two different future design stages: the component design stage, where the port is instantiated and used in the component, and the host design stage, where port instances instantiated by components are connected to other components. Component authors essentially benefit from no-code infrastructure provided by port authors, as port authors provide all the code to instantiate port instances, so that it's all done automatically for component authors. They simply instantiate ports from any port package, and their component is configured with the pro-code representation of the ports. From there, they write pro-code business logic to interact with the port as necessary. After the components are designed and deployed by component authors, the components are instantiated and connected to other ports. The connection between ports is done not through code emitted into the component, but into the host application itself.

A port of a specific type can connect to other ports if any port has defined code snippets to connect between them. Thus, ports defined inside a package can internally provide connection snippets, such as how to connect a boolean output to a boolean input. A port can also define connection snippes to other ports in completely different packages. In this way, the first port has prior knowledge of the other port, wheras the other port has no knowledge of the first port. In this way, the Virtuoso environment represents true no-code composability between content creators. As will be seen, this has important economic implications. When ports provide connection snippets for ports in other packages, a dependency is automatically formed on the other package.