Finsemble is an open terminal. It provides a terminal experience familiar to financial professionals, but provides a choice of applications, content, and data. Finsemble connects applications together, whether modern or legacy, in-house or third party. These applications actually work together intelligently, even if they weren't originally designed to do so. Finsemble cuts development time to integrate separate applications from weeks or months to hours or days. This provides an iterative path for companies who are working on updating their technology stack or who want to reduce their dependency on proprietary terminals.
This integration allows end users to benefit from customized workflows. Workflows may be explicit or implicit. Explicit workflows occur when end users deliberately perform a task with two connected applications. For example, they might share a ChartIQ chart with a client—with all data layers and annotations—through Symphony chat. Implicit workflows occur when two applications communicate behind the scenes. For example, if an end user shared a chart with a client over Symphony, a CRM like Salesforce can automatically log this activity for tracking purposes.
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. It comes with production-ready, fully customizable modular UI.
Conceptually similar apps may be grouped together. They can all be launched in concert. Moreover, with a click, the group can "hyperfocus" which minimizes everything that isn't a part of the group.
End users can snap windows together and dock them into groups to assemble the ideal workspace. A fully implemented, turnkey snap and dock infrastructure is provided. Windows can be docked to each other, the Finsemble toolbar, the edge of the screen, or to the operating system’s taskbar.
Groups of windows can have their own identity; they can be defined, saved, or spawned as a single unit by the end user. The group then operates like a “compound app” including showing as a single icon in the OS taskbar.
The Drag and Drop capability gives users the agency to share context through a simple drag and drop action. For example, a Salesforce opportunity could be dragged into a Symphony chat. This capability includes graphical indicators for appropriate drop targets as components indicate what sort of context they are able to accept.
Users of desktop applications expect to use hotkeys for quick access to frequent navigational tasks. Web-based applications present an obstacle in that they can only capture keystrokes when the browser window has focus. Finsemble solves this issue by capturing keystrokes globally and allowing individual components to register for and receive them.
The Linker allows for multiple components to synchronize on a shared context. The Linker uses a powerful but simple paradigm of colored "channels" to assign groups of components to participate in synchronization. A typical example of such a context is a stock. Choosing a stock in one component will automatically update other components oriented toward a stock, such as a chart or research component. Another example is synchronizing a customer contact across components for call management, order management, and customer relationship management.
Users have access to a single search box that can federate search requests across multiple back end services and display the returned data in a single contextualized result set. Results are actionable, allowing an end user to click on the result to bring up the associated content in the corresponding component. For instance, searching for "Apple" would bring up results for both market data and research. If Apple were a client, then it would also bring up CRM contacts. A click on any of these results would pull up either research, market data, or contact information in a corresponding component.
Workspace management allows users to create workflow-specific configurations with a mix of HTML5 and native components. Save and relaunch a workspace, restoring not only the window position, but also the internal saved state of each window. End users can pin their saved workspaces to the toolbar and launch them with a click. They can also share their saved workspaces with others in their organization. This is all managed via a customizable HTML5 workspace toolbar.
Finsemble lets developers build an application using familiar web technologies and deploy a single code base to both the browser and the desktop.
Finsemble provides hooks for developers to add an authentication component to match their specific application's needs. This includes authenticating access to the entire application or authenticating access to specific components within the application. Finsemble is agnostic about the underlying authentication mechanism, but provides both a cohesive end user UX and framework abstraction. Further, some commonly used methods are supported out of the box, such as leveraging a user’s Windows login or using OAuth. Finsemble provides a complete OAuth2 authentication client implementation.
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.
Finsemble allows developers to specify which components should share a process, and under which circumstances. This dramatically reduces memory footprint by allowing multiple components to share the same render process. Finsemble allows for maximum flexibility with splintering; 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 UI developers use a Flux/Redux "store" to manage complex application state. However, this approach only works in single page applications. Finsemble overcomes this limitation by offering a high performance inter-process store that works across window boundaries: the Distributed Store. Building with the Distributed Store allows developers to not worry about dealing with low level communications.
Finsemble can self-configure based on user identity and permissions, for instance driven by a firm’s existing entitlement system. Authentication challenges can be enabled via configuration. When a user is authenticated to a Finsemble workspace, an appropriate suite of apps and features are presented. Finsemble also provides a preferences editor where a user can customize aspects of their user experience.
For communications amongst microservices, components, or outside the container entirely, an event infrastructure provides high level protocols. At the center of this functionality is the Router API. 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.
Finsemble is built on an extensible microservice architecture. Microservices are invisible processes that provide core capabilities to components and other microservices. Finsemble ships with a set of microservices that manage core features such as workspaces, storage, or docking. Firms and third-party vendors can also add their own microservices to encapsulate their own business logic.
Finsemble makes use of pop up (toast) 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.
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 provides a persistence framework for connecting to external persistent storage (i.e., databases, tuple stores, etc.). Workspaces, windows state, and other Finsemble functions automatically use the persistence framework, eliminating the need for hand wiring. Components can use the storage API to save and restore state, ensuring that they are reconstituted appropriately during workspace reloads.
Finsemble breaks UI components down into individual "controls": atomic-level UI building blocks which you can use to build your own componentry, or customize the built-in componentry. This goes far beyond simple theming and allows for true UI extensibility.
Finsemble comes with CSS files designed to simplify the process of white labeling the UI. The CSS has been carefully crafted with semantically meaningful variables. Developers can easily change font, color, and general appearance of interface sections by overriding any of a number of core variables. For deeper stylistic changes, Finsemble makes provisions for overriding any CSS style as part of the build configuration.
Finsemble dramatically simplifies the process of building a single application from separate components.
Incorporate native applications into a Finsemble workspace using only configuration—no code changes or code control required. Once assimilated, native apps behave like any other Finsemble component, obeying layout, docking, and workspace management rules.
Finsemble’s allows deep integration of web apps into your desktop experience. This can be done even when you do not have the ability to make code changes to the component. Critically, this allows a developer to “Finsembelize” a web-deployed application without changing how it is deployed to browsers. Finsemble-specific code is injected on-the-fly when the application is loaded into the desktop. Workspace integration, symbol linking, and deep workflow integration (e.g., sharing data across the Router, pre-populating forms, automating tasks) are all possible without making code changes. This dramatically reduces integration times while reducing regression risk for stable assets.