Introduction to Finsemble

Finsemble is a desktop application framework that allows capital market developers to quickly build multi-window, multi-monitor desktop applications from HTML, .Net, and Java components. Use your own market data or a range of third-party providers with no vendor lock-in or proprietary app stores. Finsemble creates your desktop experience for your users.

Finsemble's primary goal is supplying an API for multi-window coordination and collaboration. This allows applications to be "assembled" from loosely coupled components, gaining the benefits of flexibility, scalability, and rapid development. This is achieved by use of a "microservices" based runtime which runs behind the scenes on the desktop.

The use of microservices reflects Finsemble's secondary goal: desktop extensibility and framework agnosticism as the HTML5 and JavaScript ecosystem continues to evolve. In other words, you can use React, Angular, JQuery, or any other tools to build your app!

  • A good place to orient yourself to all the reasons we built Finsemble is the MotivationsForFinsemble. This is the best place to start if you're new to Finsemble.

  • If you're a developer who wants to get their hands on the code, check out the seed project at Getting Started.

  • If you're a developer who wants a better insight into our architecture, take a glance at our tutorials—check out the Architectural Overview as a starting point.

Have questions? Reach out to

What Users Get with Finsemble

Finsemble unifies the financial professional’s desktop experience, assembling newly built, legacy, and third-party tools into meaningful, manageable workflows.

Dockable, Groupable Windows

Snap and dock windows

Snap, dock, auto-arrange, and group windows to assemble your ideal workspace. Groups of windows have their own identity; they can be defined, saved, or spawned as a single unit by the end user.

Workspace Manager

Save and restore workspaces

Pre-built workspace management allows users to designate workflow-specific workspaces for different tasks with a mix of HTML5 and native components. Save and relaunch the workspace, restoring not only the window position, but also the internal saved state of each window.


Link components by symbol, account, or other data types

Frequently, users want to share or synchronize data across components in a workspace. For instance, a typical use case in finance is to link components by stock symbol. Changing the stock symbol in one component would cause the other components to also change their symbol. The Linker API provides a high level abstraction that makes it easy for developers to provide this capability to the user.

Data Sharing

Selectively drag-and-drop data between components

Whereas the Linker provides a turnkey method for users to automatically sync context, the Drag and Drop client allows users the agency to actively transfer data. Components are able to register data types that they can emit or receive. Users can then drag and drop relevant snippets between components. For example, a Salesforce opportunity could be dragged into a Symphony chat.


Workspace and component catalog awareness

A customizable UI component and an integration with Elasticsearch provides the ability to search for and launch workspaces and apps. Soon, individual components will be able to register their contents with Finsemble. For example, a search for “AMZN” would reveal Advanced Chart -> Symbol -> AMZN, with the ability to launch a chart set to that symbol.

What Developers Get With Finsemble

Finsemble lets developers build an application using familiar web technologies and deploy a single code base to both the browser and the desktop. At the same time, Finsemble simplifies the process of building a single application from separate components.

Client-Side Integration Framework

Integrate HTML5 apps without code changes

Finsemble’s Client-Side Integration API allows deep integration of external HTML5 assets (i.e., existing apps and portals) into your desktop experience. This can be done even when you do not have the ability to make code changes to the component. Workspace integration, symbol linking, and deep workflow integration (sharing data across the event router, pre-populating forms, automating tasks) are all possible without making code changes—dramatically reducing integration times while reducing regression risk for stable assets.


Include native applications

Incorporate native applications into a Finsemble workspace. Once assimilated, native apps will behave like other Finsemble components—obeying layout, docking, and workspace management rules. Bundle native applications as OpenFin assets to create an easily deployable hybrid application. Leverage the OpenFin .Net and Java language adapters to create a seamless user experience.

Configuration-Based Process Splintering

Strategic resource allocation

Finsemble allows developers to specify which components should share a process, and under which circumstances. OpenFin dramatically reduces memory footprint by allowing multiple components to share the same render process; Finsemble splintering adds flexibility. For example, a developer could specify that Charts should share a process in groups of up to three; the fourth spawned Chart component would receive its own process.

Distributed Store

Scalability for complex applications

Most modern developers use a Flux or React "store" to manage application state. However, this only works in a single page application. Finsemble offers a distributed store in order overcome this limitation and allow for managed state across window boundaries. The benefits include far fewer dependencies when managing state across multiple windows, faster and more simplified component integration, and access to an expected (and otherwise unavailable) modern development technique.


Link to external authentication

Finsemble applications do not require authentication, but hooks are available for developers to add an authentication component to match their specific application's needs. Finsemble is agnostic about the underlying authentication type, but provides a cohesive end user UX and shared authentication framework.

Presentation Components

Toolbar, launcher, dialog, and menus

Most HTML5 UI toolkits are only meant for building single page applications. Finsemble provides UI components specific to the desktop paradigm: menus that can cascade outside of the window boundary, floating and pinned launchers that can be replicated across monitors, dialogs that float on the monitor, and window toolbars with min/max/close, and dynamic titles (e.g., streaming quotes).

UI Controls

Atomic-level UI customization

Finsemble breaks UI components down into individual “Controls”: atomic-level UI building blocks that can be customized or replaced without interfering with core Finsemble services. This goes far beyond simple theming and allows for true UI extensibility.

Webpack Hot Reload

Update, observe, and test in real time

Hot Reload for a multi-window OpenFin application is normally not feasible since HTTP limits the maximum number of client connections for a single domain. To overcome this limitation, Finsemble middleware listens for updates to Webpacked files and reloads individual components accordingly. This rapidly accelerates development and debugging.

Central Logger

Diagnosis and debugging across multiple windows

Multi-window HTML5 application debugging is inherently fragmented; by default, single logical threads span multiple windows and must be tracked across multiple consoles. The Central Logger is a comprehensive dev tool that collates console messages across the entire Finsemble application.

Dynamic Configuration

A single implementation allowing for multiple interfaces

Since most enterprise environments face a number of end user profiles, the ability to present widely varied user experiences with minimal duplicative effort becomes necessary. Finsemble solves for this with a dynamic config: a simple, distributable JSON file that allows a single Finsemble instance to present any number of curated experiences.


Communicate between components

Events allow components to coordinate activities and exchange data. Three abstractions are provided: Listen/Transmit, Query/Response, and SubPub. The Event API integrates directly with the OpenFin Inter-Application Bus so that native applications can fully participate.


Save data to local or remote DB

Provides a simple, consistent storage API for developers to persist component data. Data be saved locally or synchronized back to the client’s choice of network attached databases or data stores. Workspaces, windows state, and other Finsemble functions automatically use the storage manager, eliminating the need for hand wiring.