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 Finsemble White Paper.

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

  • 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.

Dock, Group, and Snap 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. Individual components 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.


Human interface events across window boundaries

Fintech users frequently rely on hotkeys for UI shortcuts. However, HTML hotkeys can only be captured when a window has focus, which is not the expected functionality! Finsemble solves this issue. Using Finsemble, you can use both local and global hotkeys—regardless of whether or not the app has focus.

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.


Toast notifications for any component

Finsemble makes use of pop up notifications for communicating information to the end user in a gentler way than modal dialogs. System messages and alerts are automatically routed through the notification system. Developers can leverage the API so that their components can create notifications. Unlike operating system notifications, these notifications can be interactive, allowing end users to click on them to take action.

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 Router API integrates directly with the 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.