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.
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 firstname.lastname@example.org.
Finsemble unifies the financial professional’s desktop experience, assembling newly built, legacy, and third-party tools into meaningful, manageable workflows.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.