Montage keeps component templates in HTML instead of JavaScript

A component is a web page with a script attached, not a JavaScript template

The defining choice in Montage shows up in a single sentence of the README: there are no fully JavaScript-driven templates in Montage. Each component is modeled as a stand-alone web application with its own HTML template, JavaScript, CSS, serialized component object model and resources, and with few exceptions a component can stand on the web platform like any other web page. The stated payoff is a split of labor. Designers work in the markup and styles they already know, and developers isolate and test individual components using familiar techniques. This is a direct contrast with frameworks that describe the interface in code, and it carries a cost of its own, because a page made of components is still assembled by the framework rather than by the browser alone.

Two-way bindings run on FRB, and that is where the sharp edges live

Montage builds its bindings on functional reactive bindings, in a separate project it links as FRB. A component or Montage object can establish a simple or bi-directional binding with another component or object, and when the bound property, or a deeper property path, of the bound object changes, the source object is kept in sync. The README makes a specific claim about what that buys you over traditional bindings: FRB can bind long property paths and the contents of collections, and it can incrementally update the results of chains of queries, including maps, flattened arrays, sums and averages, and it can add or remove elements from sets based on a flag changing. Incremental update is the reason to care, since a naive binding would recompute the whole chain. The counterpoint is that a second reactive system has to be learned and its update rules reasoned about.

A managed draw cycle and a serialization format in every component

The feature summary in the README lists object serialization with DOM mapping, event handling and a managed component draw cycle alongside the components and the bindings. Two of those deserve separate attention. The draw cycle is what makes the two-way bindings and the DOM mapping cohere, because the framework decides when a component is drawn rather than leaving it to each component author. The serialization with DOM mapping is what lets a component carry a serialized object model, which in turn is what makes a component reproducible from its template and its data. Combined with the encapsulation model, this is a framework organised around the idea that a component is a serializable unit with a template, a controller and a state, rather than a function that returns markup.

CommonJS, and dependencies that are not all version pinned

Montage fully supports CommonJS modules and sits in the Node and npm ecosystem. The package manifest backs that up with an overlay block that maps the browser and node entry points to core/core, redirects the montage module name, and maps the `mr` and `bluebird` module names to their locations inside node_modules. The runtime dependencies list is where this gets worth a second look. Most entries carry ordinary version ranges, such as `bluebird` at `~3.5.5` and `frb` at `~4.0.x`, but `mr` is pinned to `montagejs/mr#master`, a branch reference rather than a published version, and the manifest also carries a `proxy-polyfill`. A dependency tracked to a moving branch is the first thing to verify, because it is the part of the install that can change under you.

Scaffolding a project with minit and the port the dev server uses

The quick setup in the README is a five step path that ends with a browser window showing a Welcome component. `minit` is the Montage Initializer, a command line utility that generates prebuilt application templates and components and places the associated files in the right directories. Installing it globally comes after the Node.js installer, and the Windows variant differs from the Mac and Linux one.

$ mkdir -p ~/.npm
$ sudo npm install -gq minit@latest

Creating the project and serving it are the next two commands.

$ minit create:app -n yourappname

$ cd yourappname
$ minit serve &

The generated directory holds the default application template including the production dependencies, and the dev server listens on port 8083, so you point a browser at http://localhost:8083/ and the Welcome component loads. The README also flags a specific friction point: an EACCES warning when running minit:create is worked around with `sudo chown -R <username> ~/.npm`, which it attributes to a bug in npm.

Tests run in Node, in a browser page, or under Karma

The maintenance section is unusually complete for a project of this vintage, and it says which commands do what rather than pointing at a single test entry point. The tests live in the test directory. `npm test` runs them in Node, and opening test/run.html in a browser is the alternative for running the same suite in a browser. There is also a dedicated Jasmine runner, `npm run test:jasmine`, a Karma path with `npm run test:karma`, a watch variant for continuous runs with file change detection at `npm run test:karma-dev`, and a debug variant `npm run test:karma-debug` that opens a remote debug console on Karma. The repository root has karma.conf.js and the manifest carries karma, jasmine-core and the Chrome and Firefox launcher packages, so the browser matrix is a deliberate part of the setup.

A version number, a licence and an update that has not happened in seven years

The repository is not archived, and the last push was on 2026-08-05. The published npm version in the manifest is 18.0.0, and the most recent GitHub tags are older: 18.0.0 rc2 dated 2019-02-13, 18.0.0 rc1 dated 2019-02-07 and 17.2.1 dated 2019-02-07. So the code has seen commits in 2026 while the release history has not moved since early 2019, and that gap between recent commits and a 2019 tag is worth reading carefully rather than papering over. The package manifest declares the licence as BSD-3-Clause, and a LICENSE.md file sits at the repository root. The manifest also declares a Node requirement of >=10.16.2 and npm >=6.9.0. The README asks readers to be patient because the documentation is being updated.

Editorial conclusion

Montage fits a team that wants components to be independently testable web pages with real HTML templates, and that values a managed draw cycle and serialization over a smaller dependency tree. It does not fit a project starting today, because the last push was on 2026-08-05, the npm package version is 18.0.0 and the documentation site is described as being updated. Before you commit, run `minit serve` on a generated project and open the Welcome component, and check whether the `mr` dependency resolved to a usable commit, since it is pinned to a branch rather than a version.

Frequently asked questions

Official sources

1. Issues
2. montagejs/montage on GitHub
3. Project website
4. README
5. Releases