Released 2-1-2017

This release is certified with OpenFin version

The New

Take a Walk on the Client Side: Finsemble breaks down the borders between windows on the desktop. With Finsemble, developers can create a deep level of interaction between disparate applications using client-side integration. Release 2.1 introduces two new tools to help developers coordinate HTML5 and native applications: the Storage Adapter and the RPC Service.

By default, calls to the Storage API save data to localStorage by way of a Storage microservice. However, the Storage microservice can be adapted to suit your purposes with, well, a Storage Adapter. If you want to utilize a data store besides localStorage—such as a cloud or network based name/value store or database—you can simply create Storage Adapter to interface with that data store and plug it in. We added the default Storage Adapter for localStorage to our seed project repo so developers can clone it and spend some time tinkering.

The RPC Service grants the functionality of the Linker Client to assimilated native applications (e.g., WPF forms, .Net components, Java apps) so that they can synchronize with HTML5 components. For instance, a native component can be linked by stock symbol with an HTML5 component. Now, interoperability is even easier between HTML5 and native desktop components.

The Ecosystem Evolves: The best in fintech is becoming available through Finsemble. Both Salesforce, a leading CRM, and Symphony, a secure chat client, are now part of the Finsemble ecosystem.

Salesforce Contacts, Accounts, Opportunities, and Leads are available within Finsemble as individual components. These components can share data with one another or external third party applications through our Linker API. Salesforce components can also be primed to listen for external activity (such as a phone call or a chat message) and can automatically log that activity as a task for the appropriate Salesforce record.

Symphony contact lists and chats have been primed with Finsemble code, allowing Symphony to serve as a central hub. Advanced charts, research reports, etc., can be shared in a Symphony window via drag and drop. Likewise, Symphony activity can trigger an event in another component—such as a request-for-quote workflow.

The Improved

  • Assimilation: We fine-tuned the behavior for snapping, docking, and moving grouped assimilated windows.
  • Workspace Service: The Workspace Service now supports restoring assimilated components.
  • Storage Service: We included support for the newly-minted Storage Adapter.
  • WindowClient: Finsemble components are injected with a Finsemble window header bar. Previously, this addition might discombobulate a component if it makes heavy used of fixed CSS styles. Now, a custom header can be injected with optional CSS to allow for better compatibility with more sites. The header can also be delayed until after startup.
  • Presentation Components: The App menu now dynamically resizes to accommodate ad hoc components added by the user.
  • Miscellaneous: Finsemble now automatically adds the "finsemble" class to the root "html" element of all components. Designers can use the existence of this class to know that their application is running on a desktop, and respond with appropriate styling and layout.


Released 12-01-2017

We’re pleased to present Finsemble 2.0. This release is a culmination of significant new features, performance improvements, and API enhancements. Though the Finsemble dev team is always iterating, this release is a significant refinement of the tools provided to create multi-window desktop applications. We've also integrated with OpenFin's V8 release, leveraging the advantages therein.

Sample Presentation Components

To show how simple it is to customize components, we’ve created a suite of UI controls built with React. Each control provides a single piece of UI functionality, like checkboxes or drop-down menus. Using these controls, we assembled an array of sample components called presentation components. These presentation components are built like every other Finsemble component, and offer a beautiful out-of-the-box UI. Use the sample components wholesale for your Finsemble application, customize them for your own needs, or use them as templates to build your own.

The New

A host of new features show off the real power that comes from using Finsemble:

  • Distributed Store: Finsemble now uses a distributed store data storage mechanism, which solves the "one to many" state management problem. With Finsemble’s distributed store, developers don’t even need to learn the Finsemble API to start building multi-window desktop apps.

  • Dynamic Configuration: Finsemble can now configure itself on the fly. For instance, menus can be configured based on the results of an authentication or entitlements process. Developers can provide component configurations entirely through API calls if they desire.

  • Central Logger: The Central Logger is a unified console for viewing messages across all components and services. The Central Logger will help engineers effectively debug operations that occur across multiple windows.

  • Assimilation: You can now bring any external application into Finsemble using the Assimilation API. For situations where a deep integration is not desired or feasible, Assimilation allows you to quickly manage (launch, move, dock, and group) external desktop apps within your Finsemble application.

The Improved

We’ve fine-tuned the Finsemble framework in a number of ways:

  • Process Splintering: We’ve implemented splintering, a performance feature that lets Finsemble distribute its memory and CPU footprint across multiple OpenFin browser processes. This allows Finsemble to run lots of powerful components simultaneously. Splintering also isolates components so that the entire application can’t be affected by a single badly behaving piece of code.

  • Snap and Dock Improvements: Snapping and docking responsiveness is improved, with better real-time tracking to provide much smoother window movement along with improved snapping behavior.

  • Start-up Time Improvements: We continue to focus on performance improvements across the system. Most notable for 2.0, initialization time for the FSBL preload script has been reduced by 60%.

  • Hot Reload: We’ve added the ability to hot reload your Finsemble components, reducing your built-test cycle during development. This was implemented through Webpack by adding custom middleware to the component build process that allows your changes to appear instantly.

  • Multi-Monitor Bug: Fixed some bugs related to how Finsemble supported adding and removing multiple monitors.

  • Window Dragging Bug: Fixed an edge case where Finsemble "misses" an attempt to click and drag a window.

  • Minding our Ps and Qs: Good code is supported by good documentation. We’ve been cleaning up and improving our documentation so it’s easy for developers and code-crafty people to understand the choices we’ve made and the functionality we’ve implemented.


Released 11-03-2017

Drag And Drop Client

Drag And Drop Client is out of beta. Documentation. Tutorial. With very little code, users can:

  • Drag and drop data between components using the drag icon. Auto-highlight windows that can and cannot receive data.

  • Drag and drop items from within components

  • Easily share dropped data over applications like chat

  • Automatically use the linker to open linked windows or open pre-linked windows with shared data

New Beta Features

  • UI Controls - Substantial additional granularity for UI customization
  • Splintering - Allows splitting of components into separate processes
  • Hot Reload - Developers can see their changes in real time, without restarting the application
  • Dynamic Configuration - Finsemble can now configure itself on the fly (for instance, by user authentication)
  • Central Logger - Allows easier debugging and error logging across components

Core Changes

  • ConfigClient.get() parameters changed
  • Improved performance of dialogs created using DialogManager
  • LinkerClient now uses the distributedStoreClient, internally boosting performance
  • Improved workspace saving performance

Core Additions

  • Added system tray icon


  • Angular support in the CLI
  • Improved CLI error handling

Premium Component Updates

  • More consistent styling
  • Less resource intensive charting

Bug Fixes

  • Config macro (replacement of strings starting with $) bug fixes
  • Launcher Service crash on invalid URLs in config fixed
  • Fixed a minor docking edge case
  • Fixed an error with workspace restoration


Released 09-18-2017


Docking is out of beta

  • Window edges snap to each other and the monitor edges
  • Resizing by grabbing snapped window edges and corners resizes all snapped windows together

  • Snapped windows that form a rectangle resize proportionally as a group from the outside edges

  • Snapped windows show a dock icon and clicking the icon will dock all connected windows together
  • Docked windows move as a group

  • Outer rectangular boundary of docked groups snap to other windows, groups and monitor edges

New Beta Features

  • Data Store Client Beta: A data store similar to Facebook's Flux that can be used across components, clients, and services and fires events on data changes
  • Drag And Drop Client Beta: New Finsemble Client that allows for easy dragging and dropping of data between components

Sample Component Updates

  • Fixed issues with menu automatic sizing
  • Added ability to customize toolbar and menu items via config
  • Toolbars and Menus load faster

Core Changes

  • Breaking Change: FSBL.Clients.StorageClient.get now returns what you save. If you send in a string, you receive a string back. If you save an object, you get an object back. If you are using the storageClient, make sure to remove any JSON.parse calls inside of your callbacks.
  • Breaking Change: FSBL.Clients.LinkerClient functions now require a windowIdentifier instead of a windowName to allow the linker to work across separate Finsembleized applications (different uuid).
  • Linker window performance improvements
  • Improved overall component loading performance

Core Additions

  • External OpenFin applications can be spawned using Finsemble. See the updated spawn tutorial.
  • FSBL.getVersion(cb) will now return the Finsemble Version.


  • Ability to generate mind control components using the cli

Bug Fixes

  • Several workspace saving and restoration bugs fixed
  • Fixed issues with Finsemble window header that caused some windows to not be movable from some spots on the window header.
  • Fixed focus issues with dialog manager created dialogs


Released 07-25-2017

  • Bug fixes.
  • Added a way to quit a Finsemble application: simply call FSBL.shutdownApplication().
  • New onShutdown event. This event allows for components to register cleanup actions to be completed on application quit. For more, see the Finsemble Lifecycle.
  • New onReady event for any client that uses the baseClient. You now can add FSBL.Clients.WindowClient.addEventListener('onReady', cb). This is unlikely to be used unless you're creating a custom component. Note: We still have FSBL.addEventListener('onReady', cb).
  • Configuration Enhancements

    • Openfin manifest now modifiable in the seed project at configs/openfin/manifest-local.json
      • Config variables (e.g. $applicationRoot) supported in JSON config files for added flexibility
      • See updated Config Tutorial for more information.

    Special Note: If you customize your seed-project's environment, please review the configuration notes at the bottom of the tutorial gettingFinsemble

  • Finsemble-CLI has a new command: finsemble-cli kill. This will kill node processes that our build process spins up, as well as any lingering OpenFin processes.
  • Mind control improvements:
    • Can now specify an array of files to include in your components. Documentation
  • Toolbar and App Launcher enhancements - Documentation
    • Toolbar config now has a menuItems property to customize the items on the Toolbar
    • App launcher can now filter elements shown dynamically


Released 07-05-2017


  • Bugfixes and performance improvements.


  • Documentation updates
  • Alpha version of assimilation
  • LauncherClient improvements (e.g., better handling of monitor-connections/disconnections)
  • Allow all system components to be turned off (e.g., menus, dialogs, etc.)

Enabling Assimilation

To turn on assimilation, you will need to modify two files.

  1. First, you need to make sure that the The betaFeatures.assimilation property in configs/application/config.json matches the config below:

    "assimilation": {
     "enabled": false,
     "appAssets": [
             "src": "/hosted/",
             "version": "1.0.2",
             "alias": "assimilation",
             "target": "CppWindowsHook.exe"
             "src": "/hosted/",
             "version": "1.0.0",
             "alias": "putty",
             "target": "putty.exe"

    The appAssets property is an array of external assets that are bundled and delivered with your application. The first application in the array above is our application that brings native windows programs into Finsemble's snapping and docking; it also allows you to bundle your own applications and have them participate in the workspace. The second application is simply an example. To open it, launch NativeTest from the "Apps" menu on the toolbar.

  2. Make sure that finsemble-seed/server/FinsembleConfigs.js matches what's on GitHub,

The major changes here are bandaids. Soon we will allow you unfettered access to the OpenFin manifest. Since it is currently unavailable in the seed project, the code we've added will prepend your application's baseURL to your external assets. If you want to host assets on another server, simply put the full path in the src property of your external asset. We assume that any external application without http in its src is hosted alongside the rest of the application files (e.g., http://localhost:3375/yourSubDirectory/hosted/

  1. To add your application to the app launcher, make sure the config below is in your components.json file. Replace the alias property, the key, and the id with information related to your native application.
    "NativeTest": {
     "window": {
         "id": "NativeTest",
         "alias": "putty",
         "defaultHeight": 600,
         "autoShow": true,
         "alwaysOnTop": false,
         "resizable": true,
         "showTaskbarIcon": false,
         "contextMenu": true,
         "addToWorkspace": true
     "component": {
     "foreign": {
         "services": {
             "workspaceService": {
                 "isArrangable": true
         "components": {
             "App Launcher": {
                 "launchableByUser": true
             "Window Manager": {
                 "persistWindowState": false,
                 "FSBLHeader": true
    If you get stuck trying to add your own application, send us a note at or send us a message on slack.


Released 06-30-2017

This is the first official release of Finsemble.

New Features

  • Snapping windows: Windows now snap to monitor edges and to each other, making it quick and easy for users to assemble their ideal workspace. Snapping is automatically enabled (supported by a new service "dockingService").

  • Mind Control: Allows JavaScript to be injected at run-time into select components. You can use this JavaScript to modify the behavior of the component by interacting with the FSBL API. See the Mind Control tutorial for more information.

API Changes

  • Support for storage adapters now allow developers to save data to locations other than localStorage. Also, the Storage Client is enhanced. See the Storing Data tutorial for more information.

  • LauncherClient has been significantly revised to make component launch more flexible. The new model uses a paradigm based off of CSS div positioning, with the capability of targeting specific monitors or launching components in positions relative to other components. A new "windowIdentifier" paradigm allows windows to be referenced more flexibly. Components can now be set to spawnOnStart and spawnOnAllMonitors. They can also generically make claims on monitor space - to support building custom toolbars. See LauncherClient#spawn and LauncherClient#showWindow API calls.

    These are breaking changes from the Beta release - any calls to spawn() should be rewritten to use the new parameters.

  • The RouterClient now dynamically selects an underlying transport. For cross-domain components (i.e. components not on the same domain as the Router Service) an OpenFin-Bus transport is selected. For same-origin components a faster ShareWorker transport layer is selected. With these enhancements, RouterClient initialization is no longer synchronous, requiring a call to RouterClient.onReady() before using other Router method; however, this is transparent to components that only access the RouterClient though the FSBL object (i.e. the RouterClient is preinitialized in FSBL).

    These are potentially breaking changes from the Beta release - application should either use the RouterClient in FSBL (or for services inheriting from the baseService, reference the preinitialized this.RouterClient) or call RouterClient.onReady() before invoking other router methods.

  • WindowClient now offers fitToDOM() method that allows a window's height to automatically be resized to fit its DOM contents. This is useful for elements such as menus that have variable height.

  • A new ConfigClient provides run-time access to Finsemble configuration. See the Understanding Configuration tutorial for more information. If you participated in the Beta and wish to retain you project, then your config files will need to be modified to the new format. See "Upgrade Steps" below.

  • The Finsemble Toolbar is no longer required. If you would like to disable, simply remove the ToolBar entry under components in configs/application/config.json.

New Beta Features

  • Window grouping: Snapped windows "fuse" to form window groups. A window group can then be moved by the end user, for instance from one monitor to another monitor. Window grouping is undergoing user testing and is released as a beta for feedback. To enable window grouping set the docking.enabled flag in the configs/application/config.json file. We're currently working out the kinks in this feature, it should be enabled by default in the coming weeks.

  • Assimilation: Allows Finsemble to launch native applications from the toolbar which participate in snapping and workspaces. See the Assimilation tutorial for more information.

Other Improvements

  • Adaptable Blotter from is now available as a Finsemble component!
  • Auto Arrange can now be reversed with a second click.
  • The build process (npm run dev) has been improved to increase speed.
  • Application startup time has been improved.
  • Support for OpenFin version 7.x
  • Finsemble is now loaded via OpenFin's "preload" capability. This means that it is reliably available on any component, even cross domain!

Upgrade Steps

  1. Copy your custom services/components/clients that you've built during the beta period into another folder.
  2. Update your seed project. We've made many enhancements to the build process and configuration files - too many to give you a clean step-by-step upgrade process. A fresh clone from GitHub should be all you need to do.
  3. Delete from under your user directory AppData\Local\OpenFin\cache.
  4. Copy your files from your temporary folder back into their respective folders inside of ./src/.
  5. Make sure that your terminal is logged in to NPM.
  6. run npm install.
  7. run npm update -g @chartiq/finsemble-cli;
  8. run npm run dev.

If you have problems, contact us.


Released 05-19-2017

  • Added placeholder and hooks for authentication. See the Enabling Authentication Tutorial for instructions on building your own authentication component. The tutorial also includes information on disabling authentication.
  • The authentication placeholder (i.e. the included sample code) prompts for username and password on startup. All storage is now keyed off the username, so the configuration of the application is determined by the entered username (new usernames automatically become new users). The password field is ignored in the placeholder...any password works.


Released 05-02-2017


Released 04-21-2017

Minor bug fixes


  • Direct chat component to the correct URL.
  • Fix some icons issues in the toolbar and windows taskbar.


Released 04-19-2017

You may be wondering, "Where is 0.2?" The short answer is that Brad messed up bumping the NPM version. So 0.3.0 is what we're working with. Hope you enjoy the new features!


  • User defined components - Through the App Launcher, a user can now add their own components (Your own web pages,Google, CNN, etc.) and see them in the App Launcher.Currently, these do not persist in workspaces.
  • Allow developers to set UUID, Port, and host for local, dev, staging, and prod environments.
  • Added way for users to add storage adaptors.
  • Added support for hosting Finsemble apps on relative paths.
  • Cleaned up top-level API responses (you should parse response instead of inside of API Calls. If responding to a router request, still parse
  • Workspaces can be pinned.
  • New look and feel for the toolbar, window header, and dialogs.
  • bug fixes.


  • Documentation fixes.

Migration steps

We're aware that making changes to your project's structure is a huge pain - we certainly don't intend on making this process commonplace. For this release, however, there are several changes to the underlying application bootstrapping/build process.

There are two paths to migration:

  1. Copying the components that you've already created into a fresh copy of the seed project, or
  2. Modifying your project to match the new configuration.

Copying Components

  1. Clone the seed project into a different folder.
  2. Run npm install.
  3. run npm update -g @chartiq/finsemble-cli
  4. Use the CLI to create your components.
  5. Copy src/components from your old seed into the root of your new project.

Try to run npm run dev. Contact us if this doesn't work and we'll jump on a call to figure out what isn't set up properly.

Modifying your existing project.

  1. Replace src/node_fileserver/FinsembleConfigs.js with the file in the seed project on the master branch.
  2. create configs/startup.json; copy contents from the master branch of the seed project and put in the desired port/hostname configuration.
  3. Modify gulpfile.js

    • On line 9 paste var StartupConfig = require("./configs/startup");. Make sure to update any locations using a port number to the use startup config.
    • Replace line 143 (configPath inside of the launchOpenfin command) with configPath: StartupConfig[env].serverConfig.
    • In the gulp task devServer change launchOpenfin() to launchOpenfin("dev") Also, change all launchOpenfin function calls to the correct environment. The will match up to your startup config.
  4. run npm install.

  5. run npm update -g @chartiq/finsemble-cli;
  6. run npm update @chartiq/finsemble;
  7. run npm run dev. If it doesn't work, contact us and we'll jump on a call with you.

We apologize for the extensive changes. It's unlikely that we'll do this to you again.

The Finsemble Dev Team.

Misc Integration notes:

  1. If you have components from a previous release, that you based on our tutorial on building an application, make sure to remove this rule from your CSS.
* {
    display: block;

If you don't, you'll get some lovely CSS plastered on the background of your component's DOM.

  1. If you're playing with accountList/accountDetail from the tutorial, make sure your call to LauncherClient.getActiveDescriptors parses response instead of