Skip to content

Release history

Ashley Davis edited this page Jun 11, 2019 · 6 revisions

The release history for Data-Forge Notebook


  • Version 1 release after one year of development!
  • Fixed failure to export to code (single file and Node.js project) after moving to proper source-maps for error reporting.
  • Changed the way that 'unsaved' notebooks are distinguished from 'saved' notebooks. An unsaved notebook (say a newly created notebook or a notebook downloaded in memory from the internet must go through 'save as' to be be saved in the file system).
  • Added support for notebooks loaded from readonly files. This is mainly for the example notebooks in the Linux distribution which are stored in a read only file system. When an attempt is made to save a readonly notebook the 'save as' dialog is invoked so the user can choose another place to save the notebook and not overwrite the original readonly file. Also readonly notebooks can't be evaluated, the user must save them somewhere in order to run them. More work needs to be done on this so that example notebooks work seamlessly out of the box on Linux.
  • Added a menu item to the File to create a new window of the application.
  • Added more options for help to the welcome screen.
  • Added application icons.
  • Restarting DFN used to delete the temporary workspace, this isn't really compatible with running multiple instances of DFN so I've removed it. Soon I'll need to change it so that each instance or maybe even each untitled notebook as it's own temporary directory.
  • Start up performance improvements.
  • Added a prototype "command scripting" feature that allows a headless DFN to be automated, I'm using this in the first instance for automated testing.


  • Updated from Electron 5.0.0 to 5.0.2 to fix menus under dark themes in Ubuntu.
  • Reverted back to original font for Monaco Editor as changing to Source Code Pro causes problems.


  • Improved error handling that allows errors to be marked against the originating cell even if the code was called from a function in a different cell.
  • Now using proper source maps to translate error messages and stack traces back to a notebook. Simplified TypeScript code compilation.
  • Added cut, copy and paste of whole cells (with hotkeys Cmd/Ctrl+Shift+X, Cmd/Ctrl+Shift+C and Cmd/Ctrl+Shift+V).
  • Now flushing code changes when changing from edit to preview mode in markdown cells, previously switching modes was causing recent changes to be lost.
  • Full paths are now displayed for recent files in the welcome screen.
  • Restructured and refined the welcome screen.
  • Moved help annotations (that point out run and add cell buttons) from welcome screen to the first notebook that a user opens.
  • Added new help annotations to welcome screen to point out new notebook and open notebook buttons.
  • Added warning notifications for notebook commands that are invoked when no notebook is loaded (eg when the welcome screen is displayed).
  • The escape key now exits edit mode when editing a markdown cell.
  • Changed markdown general font to Noto Sans and code font to Source Code Pro.


  • Added "Create an issue" to welcome notebook.
  • Added links to the welcome notebook for sharing on social media.
  • Fixed issues with obscured tooltips.
  • Added hotkeys for moving cells up and down (Ctrl/Cmd+Shift+Up and Ctrl/Cmd+Shift+Down).
  • Fix a problem with move-cell-up (it was moving cells down!)
  • Removed various unecessary and annoying notifications.
  • When a file is opened it's new entry in the recent file menu replaces all previous entries.
  • Now restoring caret position after flushing code changes (to prevent the caret from being reset on save and other actions).
  • Removed the firewall popups that appear when exporting a notebook to PNG or PDF.
  • Line numbers are now only displayed for the selected cell.
  • When the Monaco Editor cursor goes off screen the notebook is now scrolled automaticallly to make it onscreen.
  • Now disposing Moncao Editor events to prevent memory leaks.
  • Fixed an issue with automatically scrolling new cells into view.
  • Fixed an issue with clicking markdown links on Linux.
  • Fixed issue with loading file associations on MacOS.
  • Removed menu and toolbar button for the welcome screen.
  • Fix to wrap error messages that were previously overflowing offscreen.
  • Revised error handling code to fix multiple issues reporting error locations and stack traces for JavaScript and TypeScript notebooks.


  • Upgraded to latest version of Electron and Electron-Builder.
  • Trimmed examples/node_modules from the DFN installer slashing it's size by more than 32% (224mb to 151 mb on PC).
  • Trimmed extra copy of Electron from the installer cutting the size gain, now up to 37% (224mb to 141 mb on PC).
  • Various fixes relating to the new charting library.
  • Can now switch charts between ApexCharts and C3. Although I'd like users to be able to easily switch between different JavaScript visualization libraries, I'm not yet sure if I'll keep C3 in the mix, but it makes for a good proof-of-concept.
  • Added some virtual blank space at the bottom each notebook.
  • Added a new example showing various types of charts that can be created with Data-Forge Notebook.
  • Moved the pre-cell run button to the top of the code cell.
  • Fixed z-index of the toolbar so that it isn't obscured by the chart toolbar.
  • Fixed issue with command "focus-next-cell", it was displaying an error when no cell was selected. Now it simply selects the first cell in the notebook when no cell is currently selected.
  • Added menu items to
    • Open the current notebook in Explorer/Finder.
    • Copy the path/name of the current notebook to the clipboard.
  • Now flushing text changes before saving, undo/redo and code evaluation. This makes that small text changes are never lost when performing an action.
  • Significant restructuring of the connection to the evaluation engine to make it more robust and reliable in the face of errors and disconnections.
  • TypeScript type definitions are now loaded in the background so that the UI doesn't hang just a notebook has been loaded.
  • Automatic npm install that is done when a notebook is loaded or as the user types code is now done as a background job so that UI performance isn't impacted.
  • Can now copy and paste 'console.log' output that is visible in a cell's output.
  • Can now copy and paste error output from a cell.
  • Fixed issues with the progress indicator while loading a notebook.
  • The size of the library Data-Forge Plot has been cut significantly so that it downloads quickly when used in a notebook to plot a chart.
  • Renabled npm module caching. This makes it faster to install npm modules after they have been previously installed.
  • Now have separate "welcome" and "intro" notebooks.
  • The "Welcome" page is now displayed on every startup.
  • Added a link to the welcome notebook to open the intro notebook.
  • Added a menu item and button to be able to open the "Welcome notebook".
  • Added a menu item and button to clear all outputs from a notebook.
  • Added a menu item and button to restart the evaluation engine.
  • Improvements to the "welcome notebook" for new users.
  • Performance improvements for layout of the Monaco Editor. Improves responsiveness when typing in code and markdown cells.
  • Clicking on a link in a markdown cell no opens the link, but no longer changes the cell to edit mode.
  • Added file associations so that double clicking a notebook in the operating system opens Data-Forge Notebook.
  • Added a protocol handler so that links starting with notebook:// open Data-Forge Notebook.
  • Added a link to the welcome notebook to open the intro example notebook.
  • Made the toolbars buttons small and minimal.
  • Insert cell button is now only shown when a cell is mouse hovered.
  • Fixes to allow intellisense to work again.


  • Fixed various issues with charts.
  • Added function 'display.chart' that can be used to directly display a chart without using data-forge-plot.
  • z issue where cells where expanding to fit new lines but not contacting when lines have been removed.
  • Disabled automatic scrolling because it's really annoying when editing a large cell (and the browser seems to scroll half decently anyway). Ultimately I need to track the cursor position within the cell and scroll to make it visible only when it isn't visible.
  • Fixed date format in the financial indicators example notebook.


  • Big change: Integrated thew Apex Charts library for much better looking charts!
  • Restructured the way notebooks are created/loaded for better performance.
    • The general npm install is now done only when a notebook is opened, this makes the first code evaluation a bit quicker and doesn't impact load performance much because it is done in parallel with other tasks when a notebook is loaded.
    • A newly loaded notebook is scanned for npm modules that referenced but not installed and then automatically installs them.
  • npm modules are now automatically installed as a user is typing.
    • @types type definition modules are also automatically installed while a user is typing in a TypeScript notebook.
  • Tweaked border and background colors for better contrast.
  • Improved performance while typing in code/markdown cells.


  • Restructured the version number to allow for point releases.
  • Fixed an issue where new cells couldn't be added to the default notebook.


  • Big feature: TypeScript support! Including:
    • Creating and evaluating TS notebooks.
    • Having enhanced intellisense/autocompletion for TS notebooks.
    • Use TS import statements and have the npm modules automatically installed.
    • Exporting TS notebooks to Node.js TS projects.
      • This includes package.json commands to run and build the TS project.
      • I've also modified the regular JS notebook export to Node.js to include a 'start' script in the package.json.
    • Exporting TS notebooks to single TS files.
    • Exporting TS notebooks to PDF, PNG, HTML and Markdown formats.
    • The TypeScript configuration file (tsconfig.json) and package file setup is automatically done for you.
  • Improved intellisense/auto-completion across the notebook.
  • The Data-Forge Notebook display functions now work with intellisense/auto-completion.
  • Fixed issue with the "Installing " progress message.
  • The "General npm install" message is now removed when code evaluation is cancelled.
  • TypeScript import statements are automatically hoisted out the code cells and inserted into global code.
  • Each instance of Data-Forge Notebook now starts and communicates with its own unique evaluation engine process. This means that multiple instances of the Data-Forge Notebook application can be open without interfering with each others code evaluation.
  • Improvements to application startup:
    • Removed creation of an unnecessary instances of the evaluation engine.
    • Removed redundant creation of empty notebook on startup. This is now unecessary because it is always replaced with the most recently opened notebook or the default starting notebook.
  • Updated the embedded Node.js version to 10.15.3 LTS.
  • Made some changes to the structure of Notebooks that are exported to the web. This is to allow exported Notebooks to be directly used in GitHub pages.
  • The 'general npm install' is now only done once per notebook.
  • Changed from Mocha to Jest for testing.
  • Big performance fixes: Restructured the undo/redo system for much better performance.
    • Drag and drop moving of cells can now be undone.


  • Added new example notebook that shows how to load, transform and save data stored in a MongoDB database.
  • Fixed an issue where saving a notebook sometimes discards a recent edit.
  • Fixed issues with syntax errors not being displayed correctly in cell output.
  • Additions and improvements to example notebooks: viz, financial indicators, Alpha Vantage example.
  • New examples for accessing mongodb from Data-Forge Notebook.
  • Fix to markdown cells so that they can be clicked and edited when new.
  • Fixed an issue with markdown cells that was preventing them from being scrolled into view when first added or when later focused or selected.
  • Fixed an issue with the popup menu that inserts cells. It wasn't being dismissed after clicking and the new cell wasn't being focused correctly.
  • Fixed an issue that would scroll a cell fully into view when the cell evaluate button is clicked. In this case the evaluation would not happened until the button was clicked again. Now clicking the cell evaluate button doesn't select or attempt to scroll the cell into view and the first click triggers the evaluation.
  • Markdown cells can now be edited while code is being evaluated.
  • The "insert cell" button in the toolbar is now a dropdown that allows any type of cell to be added.
  • Cells (code or markdown) can be inserted above or below other cells (previously only below).
  • When inserting a cell (code or markdown) and no other cell is selected the cell is inserted at the top or bottom of the notebook depending on whether you select the above or below option.
  • When selecting or focusing a cell, the cell is only scrolled into view when it is not visible. If the cell is partially visible then no attempt to scroll it into view is made. Previously select a visible cell would cause it scroll to the middle of the window, which was a bit annoying.
  • Fixed issues with syncing inserted cells to the evaluation engine.
  • Fixed issues with scrolling a cell into view when you have added a new line that is offscreen.
  • A progress indicator is now displayed while opening notebooks.
  • Cut down the amount of example data that's included with the examples. It was taking way too long to process so it's not great for a first example.
  • Clicking on a link in a markdown cell now opens the link in the system browser. I've changed the markdown renderer from react-remarkable to react-markdown to achieve this.
  • A general npm install is now done before each evaluation, this ensures that any manual changes to a notebook's package.json are accounted for.


  • Fixed 'eval cell' command so that it operates on the cell when the 'run' button next to the cell is clicked. Previously in this situation it would have just run the entire notebook.
  • Added function display.table that can display an array or object as a table.
  • New examples: Various Grademark example notebooks that show how to do monte carlo simulation, add a trailing stop loss and how to optimize a strategy.
  • Now catching c3 errors for invalid charts. Previously these wiped out the entire notebook leaving just a blank screen. Now if the user somehow manages to generate an invalid chart definition the error is handled, the chart is left blank, but it doesn't wipe out the notebook.
  • Fixed a bug that made it impossible to insert a markdown cell below another cell (it was only possible to insert a code cell).
  • Clicking on the delete button for the markdown cell was invoking edit mode, it then required a second click to actually delete the cell. This is fixed now. A single click on the delete button is now all that's needed to delete a markdown cell.
  • Fixed the scrolling of cells into view when the cell is edited. Previously this attempted to scroll the code cell and it's output into view which, for cells with large output, resulted in the cell editor being scrolled offscreen whilst being edited. Rather annoying, so now the code only attempts to scroll the cell editor portion of the cell into view.
  • Fixed the Ctrl-R hotkey to run a cell when no cell is selected, this now defaults to running the entire notebook.
  • Start up performance is slight improved due to the removal of redundant code.
  • Added '--default' command line arg that instructs Data-Forge Notebook to only load the default starting notebook and not to load the most recently used notebook.
  • Big internal restructure of the way actions and commands work so that actions have a context that can include cell, sheet and notebook.
  • Started using Spectron for automated Electron testing.
  • Add more links and resources to the Help menu.
  • Cells are no longer disabled when evaluation is in progress, you can edit your code even while it is being executed. This works because execution takes a snapshot of the code, then executes the snapshot - so it runs the code as it was when you clicked the run button.
  • Added minimum height of 1em to markdown cells so that it's easier to select them by clicking.
  • When opening a notebook from the MRU list, the current path for the open file dialog is updated to the path of the notebook that was opened.
  • Now displaying callstack and line numbers when an error is reported for a cell.
  • Enabled line numbers for cells in Monaco editor.
  • Fixed issue with automatic installation of npm module peer dependencies: previously any module that requires a peer dependency would force the dependency to be installed even if the was a later version already installed. This has been fixed and peer dependencies are only installed only when they haven't previously been installed.
  • Restructured and added automated testing for the code evaluation engine.


  • Fixed the progress spinner in the production build.
  • This version brings some big internal structural changes:
    • Removed react.di/inversify. It was too complicated to get what I wanted out of it and I suspect that it introduces unecessary performance overheads into the React component hierarchy. I've rolled my own simple dependency injection to take it's place.
    • Split the current model out into model and view-model (React compoonents make up the 'view' part of the MVVM equation here). This has allowed me to restructure the system to make it easier to manage cell selection, focus, scrolling cells into view, setting the caret position in the editor and more details like that. This and the new dependency injection system have paved the way for better unit testing of the UI. This change also allow me to better control the performance UI rendering and event handling.
    • These changes should have little or no bearing on behaviour, but please keep an eye out for new issues.
  • Fixed an issue when exporting Node.js projects. In a previous release I had started appending " export" with a space into the directory for exports and unfortunately "npm init -y" which I was using to create Node.js package files doesn't work when the containing directory has spaces (which seems a bit shortsighted of them). I've replaced "npm init -y" with some code that directly writes a generated package.json file.
  • UI fixes to ensure that newly added cells are automatically selected, focused and scrolled into view (when necessary).
  • The commands to insert cells under the currently selected cell now insert at the end of the notebook when no cell is currently selected.
  • The buttons between cells for inserting new cells have been replaced with a subtle hover menu that does the same thing but has less visual footprint on the notebook.
  • The buttons between cells for inserting new cells now insert directly after the cell with the button, rather than under the selected cell or the last cell if no cell is selected.
  • When output is appended to the selected cell, it is now scrolled into view so that the cell you are currently working with is always made visible.
  • Fixed various issues with the command palette.
    • The command palette now automatically closes whenever you invoke a command. Previously it only closed when enter was selected, but not when you clicked a command with the mouse. Now both ways of invoking a command cause the palette to close.
    • Adjusted the z index for the readonly code editor overlays so that they render beneath the command palette.
  • Fixed an issue with the layout code that was causing the scrollbar to automatically scroll backward while you are typing or deleting code.
  • DFN now remembers and reopens the last notebook you were editing, so long as that file still exists (otherwise it creates the default notebook).
  • Added new Help menu with links to documentation, resources and examples.
  • Output and errors no longer mark a notebook as modified.
  • When you open a file through the recent files menu, it no prompts you to save the current file if it has been modified.
  • An error notification is now issued when you try and open a recent file that has since been deleted.
  • Slightly increased display duration for information and warning notifications.
  • Error and success notification now remain on screen until dismissed by the user.
  • The vertical scrollbar is now reset when opening a different notebook.
  • Made a fix to the way requires are detected in the code to cover more variations of require statements.
  • When creating a new notebook there is always 1 code cell by default and it is automatically focused.
  • Now using Electron shell open function to open folders and files for the user, this should be more cross-platform and not have problems on Linux.
  • Now limiting the times when the evaluation engine is restarted. It is restarted when a new notebook is created or another notebook is opened. It is no longer restarted when undoing and redoing changes to the notebook, this is better for performance.
  • Undo / redo now sets the notebook modified flag.
  • Adding, deleting and reordering cells now sets the notebook modified flag.
  • New example notebook: loading a Node.js code module from the same directory as the notebook.
  • The Monaco Editor intellisense popup is no longer clipped to the edge of the code cell, instead it is displayed in its entirety.
  • Big feature: TypeScript notebooks are now supported.
  • Restructured the cell buttons into a popup cell menu.
  • Fixed the z-index of the toolbar so that it doesn't obscure tooltips and popups.


  • Fixed issues with error reporting. Removed the text 'Fresh' that was being displayed in errors.
  • Removed debug logging of environment when running commands within DFN. This was an unnecessary performance drain.
  • Important feature: npm peer dependencies are now automatically installed.
  • Creating a new notebook now creates an empty notebook ready for the user to start working. The default notebook (the first notebook that appears when you start DFN) is still the same introductory notebook. Clicking the "New notebook" button or menu item (or using Ctrl/Cmd + N) essentially creates a completely blank notebook.
  • DFN now supports a 'recent files list' allowing you to quickly open any notebook that you have recently opened.
  • DFN now asks you to confirm when quiting when jobs are in progress (eg export or code evaluation).
  • When exiting, creating a new notebook or opening another notebook - and the current notebook is modified but not saved - DFN will ask you if you want to save, don't save or cancel the operation.
  • Tweaked the integration of the Monaco editor so that it fits better and more seamlessly within Data-Forge Notebook.
  • Markdown cells now stay the height when switching between preview and edit modes, making the transition less jarring.
  • Tweaked styling of code and markdown cells and fixed problems with selection, focus and cell highlighting.
  • Improved responsiveness of general cell selection.
  • Improved responsiveness of switching markdown cell between preview and edit modes.
  • Big feature: Implemented undo / redo.
  • Proper use of 'debounce' to reduce events fired while user is typing and improve performance of the code editing experience.
  • Swapped the icons for the zoom buttons in the toolbars after a user made me aware they were opposite to the common convention. I also improved the tooltips of these buttons to make more sense.
  • New example notebook: Grademark backtesting API first example.
  • Moved the Quit menu from the File menu to the app menu on MacOS.


  • JavaScript and Data-Forge cheat sheets updated: Added examples of loading data from a REST API
  • npm modules and caching
    • npm modules for a notebook are now stored in the filesystem next to the notebook. A package file for the notebook is also generated in this directory. Modules are installed and the package file is created when the user evaluates a notebook.
    • This allows users to easily see and control npm modules for their project. npm modules are still automatically installed as needed.
    • npm modules are now cached for faster download. The first time a module is download it takes the full amount of time, if you subsequently use those modules again in other notebooks they will be cached and will install much more quickly
    • Bundled default modules have been removed from the installer, this reduces the size of the DFN installer and removed the first run 'setup step' that copies default modules to the notebook directory. The downside to this is that the 'default modules' are installed the first time code is evaluated (subsequent installs will be very fast due to npm caching). The initial wait for the first evaluation is too long though and I'm considering removing default modules altogether, I'm still thinking through the implications of the particular design change.
    • The first time 'setup step' when the app is first run has been removed. Removing this setup step makes the app more reliable at starting up the first time.
    • Big change: Bundled default modules have been removed from the installer and the Data-Forge libraries no longer have any special privilege in DFN.  I did this mostly to completely eliminate the 'one time setup step' but also to reduce the size of the installer. I did consider having these modules lazily installed for each notebook, but that turned out to significantly delay the time to execute a new notebook, even an empty notebook that doesn't use these modules! Of course Data-Forge and related libraries can still be used, they just have to be required in the usual Node.js way.
    • A global temporary directory is still required for installing modules, but only for new/untitled notebooks that aren't yet committed to disk. This temporary directory is automatically cleaned up whenever DFN is restarted, so it doesn't add any permanent clutter to a user's filesystem. However the npm cache directory is persistent because it's important for ongoing performance.
    • Local modules can now be required into a notebook without DFN attempting to install them via npm.
  • Big feature: Notebooks can now be exported to markdown format.
  • Added toolbar buttons to zoom in and out the notebook. I've added this for demonstrating DFN on projectors. Later I'll add keyboard hotkeys and remember the current zoom level.
  • Hotkeys and keyboard navigation:
    • Added new commands and hotkeys for keyboard navigation:
      • Ctrl/Cmd + Up = Focus next cell
      • Ctrl/Cmd + Down = Focus previous cell
      • Ctrl/Cmd + Alt + Up = Focus top cell
      • Ctrl/Cmd + Alt + Down = Focus bottom cell
    • When using keyboard navigation to change to a cell, it is automatically selected and acquires keyboard focus.
    • When a cell is selected it is automatically scrolled into view.
    • I've swapped around the run command hotkeys:
      • Ctrl/Cmd + R - run code to the current cell, or entire notebook when no particular cell is focused.
      • Ctrl/Cmd + Alt + R - always run code for the entire notebook.
    • Added hotkeys for inserting new cells after the current cell:
      • Ctrl/Cmd + Alt + Enter - Inserts a new code cell below current cell.
      • Ctrl/Cmd + Shift + Enter - Inserts a new markdown below current cell.
      • Ctrl/Cmd + Alt + D - Delete the selected cell.
    • When a cell is deleted, the next cell is now automatically selected. If there is no next cell then the previous cell is selected instead.


  • Cut the size of Data-Forge Notebook! On PC the installer was 227 mb and installed 865 mb. Now I have eliminated unecessary copies of Electron and redundant dependencies in the build and cut the size to 115 mb for the installer and 593 mb installed.
  • Fixed some issues in the code exported for single JS file and Node.js project.
  • Added missing default modules to exported Node.js project.


  • Reset the project directory in the hope of fixing a startup issue experienced by Timur.


  • Data-Forge Notebook now has a command palette like Sublime Text or Visual Studio Code. Press Ctrl+Shift+P to display it.
  • Hotkeys are now displayed in menu items, tooltips and the command palette.
  • Added new hotkeys: -- Ctrl + R to evaluate/run the current notebook. -- Ctrl + Alt + R to evaluate/run up to and including the current cell. -- Cmd + Q to quit on MacOS.
  • Export a notebook to a single JavaScript file.
  • Export a notebook to a Node.js project.
  • Improvements to menus on MacOS.
  • Added buttons between cells to add new code and markdown cells between existing cells.
  • Added buttons to move a cell up or down.


  • Big feature: You can now 'capture' your notebooks to PNG and PDF files.
  • Finalized the export to HTML feature: Restructured the export for a better result. Resulting exported HTML for notebooks now bundles all the code required without having to do an 'npm install'. Various visual improvements to the exported notebook.
  • Fixed an issue where syntax errors could accumulate after a cell each time it is executed. Old errors are now flushed out each time the notebook/cell is evaluated.
  • Fixed an issue where using Save As to save a notebook to a different folder didn't update the 'current working directory' for the notebook.
  • Fixed selection of text in cells. You can now select text and copy it from a cell's output.
  • Added new File menu item 'Open example' that allows you to directly open an example notebook (DFN includes a bunch of example notebooks).
  • Various small UI fixes and improvements.
  • Added CSV and JSON data examples to the JS cheat sheet.


  • Fix for running on older versions MacOS for Timur Carpeev. Timur was seeing a rendering issue. After research I figured it was related to GPU/hardware acceleration being enabled (seems to be a common issue for Chrome and Electron apps). I though that disabling the issue in code might solve it, but it actually reproduced the issue for me which then allowed me to fix it. In the end it was as simple as not having a background colour set to for the body element and for some reason when HW acceleration is disabled this causes the background not to be cleared, resulting in the graphical build up of garbage that Timur was seeing. Timur actually hinted early on that the the background color might be at fault.
  • The 'Open log file directory' menu item has been fixed for MacOS.

So this release sets the background colour to prevent this issue on older MacOS. Timur confirmed that it worked for him.


  • Default node modules are now bundled with the DFN installer - there is no longer an expensive one-time init process that downloads dependencies, all core dependencies are included (both Node.js and npm modules). This makes the installer much bigger, but I think it's a good trade off because it makes DFN quick to start up and get coding without having to wait for any external dependencies to download. This also makes DFN more reliable, because previously if the one-time init failed (because a download failed) it would have possibly leave DFN in an unusable state as I'm sure some of you have already seen.
  • Better startup performance.
  • Generally better runtime performance.
  • Generally better runtime stability.
  • Added a menu item (Setup -> Open log file directory) to open the directory that contains the DFN log file. This will make it easier for you to find and review the log if problems occur.
  • Various improvements to the UI, including moving the 'cell delete' button back to its original position next to each cell. for you to find the log file when reporting issues.
  • There's some new examples for charting and data viz.
  • Massive change: The evaluator engine has been overhauled. It now treats your notebooks as though it were a single JavaScript file. You can evaluate the code up until a particular cell or you can evaluate the entire notebook. The design of it has been changed so that it replicates the normal process of JavaScript coding - it is therefore easy to learn, you should be able to follow any Node.js JavaScript tutorial by typing the code into a notebook. To this end the 'input' and 'output' functions have been removed, if you don't know what those are then this change won't affect you. If you liked the idea of how the 'input' and 'output' functions made it possible to construct a 'data pipeline' then fear not these functions will make a return in a later release as an 'optional extra'. This big change paves the way for the feature to export production JavaScript code from your notebooks.
  • Added internal capability to designate code cells as having local scope. I had to add this to preserve the behaviour of some of the example notebooks. By default code cells that you add to a notebook are global (eg variables they define are in the global scope). There is no way yet for you to add local code cells via the UI, but this is something I will add in the future - it's really useful when creating examples like the JavaScript cheat sheet that's included.


Node.js is now embedded in the installer and doesn't not need to be downloaded after DFN is installed. Generally better startup performance. Added new examples for working CSV files, JSON files and rendering charts. Fix: Can now copy and paste your licence key into the input field on MacOS.


Upgraded and restyled the UI. Now using Blueprintjs instead of SemanticUI. Removed manual resizing of the code editor. Markdown cells are now simply clicked to be edited.

First pass at the export notebook feature. This allows you to export a notebook to HTML.

Cells can now be rearrange by drag and drop.

Improved startup performance of the evaluation engine.

Made the first edit of the Data-Forge Notebook wiki. You can find it here: Please feel free to contribute.


Trim the whitespace in the cell after the cursor is no longer active in it, whether the markdown or code cell. Requested by Sean Hoar

Various improvements for stability, reliability and performance.

New examples: web scraping demo, JavaScript cheat sheet from my book Data Wrangling with JavaScript.

New feature: Display HTML and allow devtools to inspect (useful for web scraping).

The current working directory for code evaluation now defaults to the parent directory that contains the notebook. This allows data files to be easily loaded when they are placed in the same directory as the notebook. See the new 'file-system-test.notebook' for an example.

Added a menu item that allows the one-time setup to be obliterated and redone. This means if there is something wrong with the default setup (Node.js + default npm modules) they can easily be reinstalled without have to manually fiddle with the file system.

The input function now throws an error when a requested input doesn't exist.

Previously it was trying to install built-in modules like 'fs' through npm. I've modified the code so that it now ignores the built-in modules although to start it only ignores 'fs' and I'll add more to the list over time.

Get Data-Forge Notebook

You can’t perform that action at this time.