Rust inside. JavaScript outside.

The engine that schedules and draws 50,000 tasks is written in Rust. Your team never sees it: you install a package, call a typed API from JavaScript or TypeScript, and style it with CSS.

Your appReact, Vue or plain TypeScript. Your toolbar, your data, your routes.
The chart's APITyped TypeScript: mount, load, commands and events. The only part you touch.
The engine, Rust compiled to WebAssemblyReads P6, MS Project and JSON; computes every date; lays out the rows.
The GPUWebGPU, or WebGL2 where a browser lacks it, draws each frame.
Everything below the line is inside the component. You work above it.

Why Rust

A Gantt chart is a scheduling engine with a picture on top. Every drag re-solves the schedule: each task's early and late dates, its float, the critical path, through calendars, lags and four kinds of link. At 50,000 tasks that is a lot of arithmetic to do between two frames.

Rust compiles to tight machine code and has no tracing garbage collector, so the engine never stops for a collection pause in the middle of a drag. When you change one task, the engine starts from the tasks that change can reach and widens the work only when it has to, as when the project's finish moves.

The same engine runs outside the browser too: Node opens P6 and MS Project files with it (tachlon/headless), and its tests run in milliseconds without a browser.

Why WebAssembly

WebAssembly is how compiled code runs in every modern browser, next to JavaScript and at close to native speed. The Rust engine is compiled once, into one file, and the browser loads it like any other asset.

It runs on the page's main thread, single-threaded. That keeps it simple to host: no Web Workers to wire up, no shared memory, and none of the cross-origin isolation headers that threaded WebAssembly needs.

Why the GPU

A chart of 50,000 tasks is tens of thousands of bars, links, labels and grid lines. Drawn one by one into the page, they make the browser lay them out again on every scroll. Handed to the GPU as one scene, they are drawn in a single pass each frame, the way a game draws.

The chart uses WebGPU where the browser has it and falls back to WebGL2, which current Chrome, Edge, Firefox and Safari ship. The task table beside the chart stays ordinary HTML, so its text is selectable, readable by a screen reader and styled by your CSS.

What it means for a JavaScript team

Do we need Rust, or a Rust toolchain?

No. The package on npm carries the compiled engine. You install it like any other dependency, and your build never compiles Rust.

Is it typed?

Yes. The package ships TypeScript declarations for the whole API, and the reference is generated from the same source.

What does it add to our bundle?

The engine is one WebAssembly file: 2.2 MB gzipped (gzip -9) in a release build of main on 11 November 2026, plus the chart's own JavaScript and CSS. It is a static file your server can cache, and you can load it only on the pages that show a chart. A byte budget in CI keeps it from growing.

Does it work with our framework?

The core mounts into any element, so it works anywhere. A React component wraps it.

Server-side rendering?

The chart draws in the browser, so it renders on the client. In a server-rendered app, mount it after hydration, as you would a map or a code editor.

Our site has a Content Security Policy.

If your policy restricts scripts, add 'wasm-unsafe-eval' to script-src so the browser may compile the engine. Allow an engine file in connect-src, even one on your own origin, unless connect-src or default-src allows 'self'. Scripts, styles and fonts follow the rules you already have for any package.

Special headers, workers, threads?

None. The engine is single-threaded on the main thread, so no Cross-Origin-Opener-Policy or Cross-Origin-Embedder-Policy headers are needed.

Which browsers?

The chart needs WebGPU or WebGL2. Current Chrome, Edge, Firefox and Safari ship WebGL2, though a machine's drivers or policy can turn it off; then mount rejects with a MountError that says why. WebGPU also needs an https page and a usable GPU. If WebGPU fails, the chart moves to WebGL2, inside its own box, without reloading your page.

How do we debug it?

From JavaScript, like the rest of your app. mount rejects with a MountError if the first schedule cannot be read or the first frame cannot start. After that, load returns a result instead of throwing, and a failed open or a failed frame shows a message on the chart and fires an error event your code can listen for.

Is it open source? What does it cost?

No. Tachlon is proprietary. It is free to try, with a small "Unlicensed" mark outside localhost. It is not on sale yet, and the planned prices are on the product page.

Can we make it look like our product?

Yes. Colors are documented CSS tokens, in light and dark; the bar shape, row height and type are CSS tokens too.

See it at 50,000 tasks.

Back to the product, or open the demo in your browser.