Origin Charts — a charting library written entirely in Rust
Origin is the charting engine behind Axiusflow: full Rust, compiled to WebAssembly, rendered on the GPU. Where JavaScript charting libraries like Lightweight Charts, Highcharts Stock, and ApexCharts pay a garbage collector on every frame, Origin allocates nothing in the render path — so it holds 60fps on a quarter-million bars instead of decimating them.
Enterprise licensing comes with lifetime support at the lowest cost in the market.
Origin is not publicly distributed — companies request access and we follow up with a technical review.
Origin Charts running live
This is the real engine with 25,000 bars loaded, running in your browser right now — switch series types, pan, zoom, and scrub it. The readout is live: frame rate is sampled from your own browser, and it holds while you scrub because only the visible slice is drawn.
Performance is the whole point
Charting is a soft real-time problem. A renderer that averages well but pauses at the wrong moment is a renderer you cannot trade on. Origin is built so the slow frames never arrive in the first place.
Figures are the engine's design targets, measured internally on reference hardware with synthetic OHLC data. Real-world results vary with browser, GPU, dataset, and how many overlays you have on screen.
Rust in the hot path
Layout, scaling, hit-testing, and geometry generation all run in compiled Rust. There is no JavaScript object churn per frame, so the browser never has to stop the world to collect garbage mid-scroll. Frame times stay flat instead of sawtoothing.
GPU-accelerated drawing
Origin renders through WebGPU where it is available and falls back to Canvas2D everywhere else. Geometry is uploaded once and transformed on the GPU, so panning and zooming are matrix updates rather than a full re-tessellation of every candle.
Deterministic frame budget
Work per frame is bounded. Series data is stored in flat, contiguous buffers and only the visible slice is touched, so rendering cost tracks what is on screen — not how much history you loaded. A 1-year and a 10-year dataset cost about the same to draw.
Memory safety without a runtime
Rust's ownership model gives us the safety guarantees of a managed language with none of the runtime overhead. No null dereferences, no data races in the worker pipeline, and a WASM binary small enough to stream in before the first bar arrives.
Origin Charts vs JavaScript charting libraries
Lightweight Charts, Highcharts Stock, ApexCharts, Chart.js, and hand-rolled D3 canvas builds are all well-engineered — and all share one architectural constraint: their render path runs on the JavaScript heap. That is the difference Origin is built to remove, not a criticism of how they were written.
| Dimension | Origin Charts (Rust) | JavaScript chart libraries |
|---|---|---|
| Implementation language | Rust, end to end — compiled to WebAssembly | JavaScript or TypeScript, interpreted and JIT-compiled |
| Garbage collection in the render path | None. No JS objects allocated per frame | Unavoidable. Per-frame allocation drives GC pauses |
| Rendering backend | WebGPU, with a Canvas2D fallback | Canvas2D or SVG; WebGL in a few libraries |
| Frame-time consistency under load | Flat — p99 sits close to the median | Spiky — GC and layout cause periodic stalls |
| Bars before interaction degrades | ~250,000 with smooth pan and zoom | Typically tens of thousands before decimation is required |
| Scaling, hit-testing and geometry | Compiled Rust operating on flat, contiguous buffers | JS loops over object arrays, re-walked each frame |
| Memory model | Ownership-checked at compile time; no data races | Managed heap; fragmentation grows with session length |
| Native desktop parity | Same Rust core compiles to a native library | Browser-only, or wrapped in Electron |
| Support model | Lifetime support included with every enterprise licence | Community issue trackers, or support priced per year |
| Enterprise licensing cost | Committed to the lowest cost in the market | Commercial libraries commonly reach four to five figures per year |
The right-hand column describes the common architecture of browser charting libraries rather than any single product; specific capabilities vary between them. Lightweight Charts is free and open source, so the licensing row applies to commercial enterprise charting products. Lightweight Charts and TradingView are trademarks of TradingView, Inc.; Highcharts is a trademark of Highsoft AS. Origin Charts is an independent product and is not affiliated with either.
vs. Lightweight Charts
TradingView's open-source JS library is genuinely good, small, and free — for many projects it is the right answer. But it renders on Canvas2D from the JavaScript heap, so the moment your dataset or overlay count grows, you are paying for decimation and living with GC-driven jitter. Origin's Rust core removes both constraints instead of managing them.
vs. Highcharts Stock
Mature, feature-dense, and well documented, with an enterprise licence to match. Origin targets a narrower brief — market data rendered as fast as the hardware allows — and prices its enterprise licence to undercut, with lifetime support rather than an annual support renewal.
vs. ApexCharts / Chart.js
Excellent general-purpose libraries built for dashboards and business reporting, not for scrubbing a quarter-million bars at tick frequency. They will render a candlestick chart; they were not designed to hold 60fps while one is streaming.
vs. D3 and custom canvas builds
Maximum control, and the cost is that you now own a rendering engine. Teams that go this route typically rebuild scales, hit-testing, and pan/zoom from scratch, then hit the same JS-heap ceiling a year in. Origin is that engine, already built and maintained.
How it is put together
Four layers, and only one of them is JavaScript — deliberately the thinnest one.
Your application
React, Vue, Svelte, or plain TypeScript. You call a typed API — create a chart, add a series, set data.
Thin JS/TS binding
A small wrapper that marshals options and data into the WASM module. No per-frame work happens here.
Rust core (WASM)
Scales, layout, visible-range computation, geometry generation, crosshair hit-testing, and animation.
WebGPU / Canvas2D backend
GPU path where supported, Canvas2D fallback everywhere else. Same output, same API, different backend.
What the engine ships with
A small API on top of a large engine
All of the complexity — scales, tessellation, GPU buffers, hit-testing — stays inside the Rust core. What you touch is a typed TypeScript surface: create a chart, add a series, set data. Quarter of a million bars is the same four calls as five hundred.
The module is browser-only and WASM-backed, so it is loaded lazily and kept out of your server render and initial bundle.
import { create_chart } from "@tradeaion/charts";
const chart = await create_chart(container, {
layout: { background: { type: "solid", color: "#0b0b0b" } },
crosshair: { mode: 0 },
autoSize: true,
});
const candles = chart.add_series("candlestick", {
up_color: "#34d399",
down_color: "#f87171",
});
candles.set_data(bars); // 250,000 bars
chart.time_scale().fit_content();Why we built our own engine
Why not just optimize JavaScript?
We tried. A well-tuned JS renderer can hit 60 fps on a quiet chart, but it degrades in exactly the moment that matters: a volatile session with a dense series, several overlays, and ticks arriving continuously. The cost is not raw arithmetic — it is allocation pressure and the collector pauses that follow. Rust removes that entire class of problem instead of deferring it.
Predictability beats peak throughput
A chart that averages 60 fps but stutters twice a minute feels worse than one that holds a steady, slightly lower rate. Origin is tuned for the shape of the frame-time curve, not the average. Bounded per-frame work and no GC means the p99 frame time sits close to the median.
One engine, every surface
The same Rust core compiles to WebAssembly for the browser and to a native library for desktop. Behaviour, math, and pixel output stay identical across surfaces, so a chart looks and reacts the same whether it is in a tab or in a native shell.
Built against a real product
Origin is not a side project — it is the engine Axiusflow itself runs on. Every performance regression shows up in our own product first, and every feature is shaped by real charting and trade-review workloads rather than a synthetic benchmark.
Lifetime support. The lowest enterprise cost in the market.
A charting engine is infrastructure — you will still be running it in five years. So we license it that way: one price, support that does not expire, and no meter running on your seats or your domains.
Lifetime support, included
Every enterprise licence includes support for the lifetime of the licence — not a twelve-month window that lapses into a renewal invoice. Bug reports, integration help, and upgrade guidance come from the engineers who wrote the engine, with no separate support SKU and no per-incident charge.
The lowest enterprise cost in the market
We price Origin to be the lowest-cost enterprise charting licence available. If you are holding a competing quote for a comparable engine, bring it to the conversation — undercutting it is the commitment, not a negotiation tactic.
No per-seat or per-domain metering
Licensing is per company, not per developer, per dashboard, or per deployed domain. You should not have to audit your own headcount to stay compliant with a charting library.
Direct line to the engine team
No ticket queue and no first-line triage. Licensed teams talk to the people who can change the engine, and the roadmap is shaped by what those teams actually run into.
Getting access
Origin Charts is not published openly. It is a proprietary engine, and access is granted to companies case by case so we can support each integration properly rather than shipping into the dark. There is no self-serve download and no open-source mirror.
Reach out with what you are building, the data volumes involved, and the surfaces you need to support.
We look at whether Origin is the right fit. If your workload needs something the engine does not do yet, we will say so.
Approved teams get package access, documentation, and a direct line to the people who build the engine.
Origin Charts — FAQ
What is Origin Charts?
Origin Charts is a financial charting library written entirely in Rust and compiled to WebAssembly. It renders candlestick, area, line, and histogram series with multi-pane layouts, overlays, crosshair interaction, and real-time streaming. It is the engine that powers Axiusflow's own charting, and it is available to companies under an enterprise licence.
Why is Origin Charts written in Rust?
Because charting is a soft real-time workload. Rust gives us compiled performance and memory safety with no garbage collector, which means no unpredictable pauses during a volatile session. Layout, scaling, geometry, and hit-testing all run in compiled code instead of on the JavaScript heap.
How fast is it?
On our reference hardware, Origin sustains 60 fps pan and zoom on datasets of around 250,000 bars, with a typical full candlestick repaint using under a millisecond of the frame budget. Because only the visible slice of data is touched each frame, rendering cost scales with what is on screen rather than with how much history is loaded.
How does Origin Charts compare to Lightweight Charts?
Lightweight Charts is TradingView's open-source JavaScript library — small, free, and a good fit for many projects. It renders on Canvas2D from the JavaScript heap, which means allocation per frame and garbage-collection pauses once datasets or overlay counts grow, so large series usually have to be decimated. Origin is written entirely in Rust and allocates nothing in the render path, so it holds a flat frame time on roughly 250,000 bars without decimation. Origin is also proprietary and licensed, where Lightweight Charts is free.
Is a Rust charting library actually faster than a JavaScript one?
For this workload, yes — and the reason is consistency rather than raw arithmetic. Modern JavaScript engines are fast, but a charting render loop allocates objects every frame, and the garbage collector eventually stops the world to reclaim them. Origin's Rust core keeps series data in flat, contiguous buffers with no per-frame allocation, so the p99 frame time sits close to the median instead of spiking. It also only touches the visible slice of data, so cost scales with what is on screen, not with how much history is loaded.
Does it require WebGPU?
No. Origin uses WebGPU when the browser exposes it and falls back to Canvas2D otherwise. The API and the visual output are the same either way — only the backend changes.
How much does an Origin Charts enterprise licence cost?
Origin is priced to be the lowest-cost enterprise charting licence in the market, and licensing is per company rather than per seat, per developer, or per deployed domain. If you are holding a quote for a comparable commercial engine, bring it to the conversation. Exact pricing is set during the access conversation because it depends on deployment scope.
What support comes with the licence?
Lifetime support is included with every enterprise licence — support for the life of the licence, not a twelve-month window that lapses into a renewal invoice. There is no separate support SKU and no per-incident charge, and you talk directly to the engineers who build the engine rather than a first-line ticket queue.
Can I use Origin Charts in my own product?
Yes, under an enterprise licence. Access is granted to companies on request rather than published openly. Use the Get Access button to tell us about your use case, your data volumes, and the platforms you need to support, and we will follow up with a technical review.
Is there a free or open-source version?
Origin Charts is proprietary. There is no public open-source release today. Companies that need it in production should reach out for access and an enterprise licence.
Want Origin in your product?
Tell us what you are building and the data volumes involved. If Origin is the right fit, we will get you set up and stay close while you integrate.