Open source
Ripple Effect is proprietary and its source is not published. Several of the packages it is built on are open source, and four of them are ours: the node editor, the docking layout the workspace is drawn with, the reading-time estimate and the crash reporter. The distinction is worth keeping straight, because the two halves are easy to blur: the packages are open, the app is not. The four are published on their own and take pull requests. fl_nodes_v2, fl_panel and fl_crashpad are Flutter packages and need Flutter; dart_read_time is pure Dart. The bindings that let other programs play a campaign are open source too, though the engine they carry is not.
fl_nodes_v2: the node editor
Section titled “fl_nodes_v2: the node editor”github.com/ConnectingTheDots-DCWK/fl_nodes_v2 · MIT
This is the canvas: geometry, wiring, selection, undo, the execution model (control pushed, data pulled) and the minimap. It knows nothing about narrative. A node is whatever the host says a node is, and Ripple Effect is one host. Everything about how a card behaves on the canvas, described in Boards, nodes and macros, is this package behaving, and a contribution there reaches Ripple Effect and every other application built on it.
fl_panel: the docking layout
Section titled “fl_panel: the docking layout”github.com/ConnectingTheDots-DCWK/fl_panel · MIT
This is a tree of splits, single panels and tab groups that you resize, dock and rearrange. You can tear a tab out of its strip, drop a panel beside another and get the same layout back tomorrow. Every panel holds ordinary Flutter widgets, and nothing about files or documents is in the package: a tab is a name the host resolves. What may go where is answered by the tabs themselves and by a policy the host writes, so an application can say that its tool panels only share a strip with tool panels.
It is what the workspace is drawn with. The project page is one docking area over this package: the documents are tabs and splits, and the layout is kept per project in .ripple/workspace.json. The package went public first so that it was built in the open rather than around one application’s shape. Its tree, solver and file format import nothing from Flutter, so a layout can be built, edited and saved headless. The post that introduces it says why the tree is the shape it is.
dart_read_time: how long a passage takes to read
Section titled “dart_read_time: how long a passage takes to read”github.com/ConnectingTheDots-DCWK/dart_read_time · MIT
This is the estimate under every passage: fifty-four languages, mixed scripts counted a run at a time, and an honest word about whether the figure for a language is measured or reasoned. It is pure Dart with no Flutter in it, so a browser or a command line can use it too. Passages, choices, languages and reading time says what the row under the editor does with it.
fl_crashpad: native crash reports
Section titled “fl_crashpad: native crash reports”github.com/ConnectingTheDots-DCWK/fl_crashpad · MIT
This is native crash reporting for Flutter over Google Crashpad, on desktop, Android and iOS. It knows nothing about any app, logger or backend. In Ripple Effect it catches a native crash; every report is sanitised before it can be read or sent. Updates, logs and Messages covers what the app does with a report.
The engine’s bindings
Section titled “The engine’s bindings”| Binding | Repository | Published as |
|---|---|---|
| JavaScript and TypeScript | ripple_effect_js_ts_integration | @ripplefx/player and @ripplefx/soundscape on npm |
| C and C++ | ripple_effect_c_cpp_integration | GitHub releases, consumed with CMake |
| C# | ripple_effect_csharp_integration | RippleFx.Engine on NuGet |
| Dart | ripple_effect_dart_integration | ripplefx_engine on pub.dev |
These are how a game, an app or a page plays a campaign exported from the editor. Each is MIT. The engine each one carries or downloads is not: it is a compiled build of the engine, under the Runtime Licence, which lets you ship it unmodified in function as part of your own product. @ripplefx/soundscape carries no engine and is plain MIT. Embedding the engine explains what they share, and How the engine ships explains what they put in your build.
monty: Python, in a sandbox
Section titled “monty: Python, in a sandbox”github.com/pydantic/monty · MIT
Not ours. monty is a sandboxed Python interpreter written in Rust by the pydantic team, and it is how a Script node, a {{ … }} span in a passage and the console run Python at all. Our thanks to runyaga, whose dart_monty first brought the interpreter to Dart. The engine links the interpreter directly, and a runaway script is stopped at its deadline.
The interpreter is a subset of Python: no filesystem, no network, no class, and a standard library that is a short list. That restriction is what makes it safe to run a stranger’s story. Python in a story explains the trade, The sandbox and its limits says what it allows, and the Python reference lists what the app binds into it.
Harper: spelling and grammar
Section titled “Harper: spelling and grammar”github.com/automattic/harper · Apache-2.0
Not ours. Harper is a grammar checker written in Rust, and its harper-core is what checks the spelling, grammar and style of English passages and notes, on your machine, as you write. The style rules a project writes for itself are in Weir, Harper’s rule language. How to check spelling and grammar and How to write a style rule say how to use it.
parakeet-rs: dictation
Section titled “parakeet-rs: dictation”github.com/altunenes/parakeet-rs · MIT or Apache-2.0
Not ours. parakeet-rs runs NVIDIA’s Nemotron streaming models, which is how dictation hears you on your own computer. The models are not part of the app: each is downloaded when you ask for it, and they are under NVIDIA’s licences rather than ours. How to dictate a passage says how to set it up.
Everything else
Section titled “Everything else”The complete list of third-party components and their licences is in the application, under Settings → About → Third-party licences. Each is governed by its own licence, which the app’s does not touch. Since 1.6 the list also covers the native code inside the packages, among it the audio player and FFmpeg, Git, the PDF viewer, crash reporting and the spelling checker’s word list, and the icon fonts, the app’s three typefaces and the two speech models dictation downloads.
Related
Section titled “Related”- Licensing: the terms the app itself is under.
- The workspace window, menus and palette: what the docking layout looks like in use.
- Python in a story: why scripts run in a sandbox.
- A project is a folder: where
.ripple/workspace.jsonsits. - The sandbox and its limits: what a script may do.
- What the app sends: what leaves the machine, including crash reports.