Skip to main content
Blog

ET1 Is Now n0is: What Changed After JavaScript

ET1 is now n0is. Tyler Garrett explains the move from a JavaScript data engine to C++, the measured gains, and the broader local-first workspace.

· Tyler Garrett

n0is C++ engine: 33 times median speedup over original JavaScript across 57 cases at 250,000 rows; case range 4.7 to 1,356 times; a separate parity set has 627 matching-output checks.

ET1 software is now named n0is. If you found our work through the ET1 tutorials, visual data transformations, or node documentation on Dev3lop, this is the next chapter of that product.

The name change accompanies a larger engineering change. The data engine moved from JavaScript to native C++, and the product grew beyond its original visual ETL workflow into a workspace for data, dashboards, diagrams, and local AI assistance.

JavaScript helped me get the original idea into people’s hands. Returning to C++ gave me more control over how the engine stores data, allocates memory, schedules work, and moves results between operations. The useful story is what those decisions changed—and what the measurements actually support.

From ET1 to a broader workspace

ET1 started with a direct premise: make data transformations visible. Load a table, connect operations, inspect the intermediate results, and understand how the answer was produced. That remains central to n0is.

The surrounding workflow has expanded. People can work with data on their own computers, use Neo for assistance, build dashboards, and work with Rug diagrams. Shared workspaces let them choose which files, workflow definitions, and results to share with collaborators.

That is why the new name matters. n0is describes the broader product, while ET1 still appears in parts of the workflow tooling and older documentation. Existing ET1 articles remain useful historical guides, although screenshots, menus, and individual capabilities may differ from the current app.

For current capabilities, start with the n0is feature catalog. For the latest shipped changes, use the changelog.

The measured win over the JavaScript engine

The published engine measurements report a 33× median speedup over the original JavaScript engine, measured across 57 cases covering 23 nodes at 250,000 rows. The reported range runs from 4.7× to 1,356×.

Download the benchmark graphic (PNG) or open its vector version (SVG).

Those boundaries matter. This is a comparison of specific engine operations and inputs on the recorded machine, an Apple M5 Max with 18 cores. It is not a claim that every dashboard, file import, or user interaction becomes 33 times faster. The wide range also shows why the median is more useful than leading with the largest result.

The same published record lists 627 out of 627 matching-output cases between the original JavaScript and C++ implementations. That is an essential companion to the timing result. A faster transformation is only useful if it preserves the behavior people depend on.

Passing those cases establishes agreement on that test set. It does not prove that every possible input is equivalent, and the speedup and parity figures describe different sets of checks. Both belong in the engineering record.

More control over memory and execution

The architectural win is that representation and execution decisions can be designed together.

In a data pipeline, the cost of an operation includes more than its central loop. Parsing text into typed values, building dictionaries, allocating output, materializing intermediate tables, and keeping old results alive can all affect the experience. C++ makes it possible to work directly on those costs in the native engine.

That control creates opportunities; it does not automatically produce an efficient implementation. We still have to find unnecessary work and demonstrate that a proposed change helps.

One example appears in the Ports as Instruments research paper. A separate interleaved C++ comparison at one million rows reduced the median for a sum-by-region step from 7.46 ms to 1.13 ms across nine process runs per build. That revision converted columns once and simplified group bookkeeping. All 613 JavaScript parity cases available at that revision passed.

This was an improvement within the C++ implementation, rather than another JavaScript-to-C++ speedup. It illustrates the ongoing benefit of the rewrite: the engine gives us room to improve the physical work behind an existing operation while checking its semantics.

Other languages made the C++ engine better

Leaving the JavaScript engine also opened a useful research process. Implementations in Swift, Rust, Zig, and Go provided alternative ways to approach the same kernels. A competing implementation can expose a better algorithm, a cheaper representation, or simply work that the original benchmark did not count.

The research did not produce a universal language ranking. For example, the CSV timing study in Zig and n0is C++ reports that Zig led the one-million-row first load, while n0is C++ led warmed loads at both tested sizes. The ten-million-row first-load interval spanned equal times.

First load and repeated load are different user experiences. Memory use can also move in the opposite direction from elapsed time. We preserve those distinctions instead of combining favorable numbers from unrelated experiments into one headline.

The newer experiment graph continues that investigation. Its workload-specific C++ and Zig branches remain research unless they have been separately qualified for a release. An automatic workload-adaptive runtime planner is still a research direction, not a capability we claim to have shipped.

A native app, with deliberate sharing

The move supports a product organized around local computation. In n0is, people can keep working with local files and choose what they share. AI models are separate downloads, and connecting an external service is a separate decision.

The shared workspace still uses online services for accounts, collaboration, and delivery. The website and browser interface still use JavaScript. Moving the data engine to C++ does not mean the entire product has become JavaScript-free, or that all browser clients execute the native engine.

The practical win is having an explicit place for each responsibility: native data processing on the desktop, with online collaboration for the artifacts people choose to share.

Try the current n0is release

The current Mac alpha, build 2026.1115.1, is available through the n0is download page. It is Developer ID signed and Apple notarized, requires a verified n0is account, and targets Apple Silicon running macOS 26 or later. The release also includes fixes for selected-transcript context, saved Rug diagram opening, and overlapping import refreshes.

You can read the research papers and download their PDFs, inspect the benchmark record, or explore the shared workspace.

ET1 gave us the visual pipeline foundation. n0is carries that work forward with a native engine, a broader workspace, and a public record of the measurements behind its progress.