GUI toolkits
Draw widgets well, but leave the data to you: no live tables, no incremental sorting or grouping, no streaming.
Vision
From the data stream to the pixel.
densa is becoming an open, native platform for real-time data applications: the engine that keeps live data in order, and the interface that shows it, in one Rust stack.
Why
Data-heavy software is built from parts that were never designed together
Trading desks, operations centers and engineering teams build screens that follow thousands of values changing every second. Today they assemble them from separate pieces, and pay for every seam between them.
Data engines
Arrow, DataFusion, Polars and DuckDB process data superbly, then stop at a result set. Showing it live is someone else's problem.
Web dashboards
Reach every browser, but run in a sandbox with a garbage collector between the data and the screen, and struggle beyond thousands of updates a second.
densa
One native stack, Arrow from end to end: live data structures, views that update incrementally, and a GPU interface that never allocates while it draws.
The platform
Four layers, each usable on its own
-
1
Interface
GPU rendering, real text and editing in every script, a data grid, and widgets with flexbox layout, events, focus, themes, docking workspaces and screen reader support, and the data grid as a widget. Next: menus.
In progress -
2
Live data engine
Arrow-native tables updated by key, and views whose sorting, filtering, grouping and aggregates update with each change instead of being recomputed (available). Next: time windows and joins.
In progress -
3
Visualization
GPU charts for millions of points: time series, candlesticks, heatmaps and depth, linked to the grid so a selection in one filters the other.
Planned -
4
Connectors
Arrow Flight, Kafka, NATS, WebSocket, Parquet and CSV, and the engines that already speak Arrow: DataFusion, Polars, DuckDB.
Planned
Flagship application
densa Studio
An open-source application built on the platform: open a Parquet file, a CSV or a live stream and explore it at once, in grids and charts that keep up with the data. It proves the platform in daily use and gives everyone a reason to try it.
- Open files and streams; tables with millions of rows
- Sort, filter and group interactively while data keeps arriving
- Charts linked to tables; workspaces saved and restored
- Extensible with plugins, built only on public densa APIs
Roadmap
Phases
Each phase ends with something usable, measured and documented. Nothing marked next or planned is available yet.
-
Foundations
Done
GPU canvas and data grid, paragraphs, selection, editing with input methods, wait-free data hand-off, Apache Arrow tables in the grid.
-
Phase A: done
Live data and widgets
The live data engine's core: keyed tables, incrementally maintained views and grouped aggregates. The widget foundation: flexbox layout, events, focus and themes, docking workspaces, screen reader support, and text in every script.
-
Phase B: next
Grid, charts and connectors
The data grid as a widget (available), showing live views in docked panels; GPU charts linked to tables; the first connectors for files, streams and query engines.
-
Phase C
densa Studio 0.1
The flagship application, crates published on crates.io, and full documentation here.
-
Phase D
Web and plugins
The same applications in the browser through WebAssembly and WebGPU, and a plugin system.
Principles
What will not change
Measured, not claimed
Every performance figure names its hardware; every guarantee is a test.
Nothing allocates per frame
Startup and changes may allocate; drawing, scrolling and steady state may not.
Arrow from end to end
Data stays in Arrow's columnar form from the source to the screen, shared rather than copied.
Libraries first
Every layer is a set of crates usable on its own; the Studio uses only public APIs.
Open source
MIT or Apache-2.0, developed in the open on GitHub.
Native first
Desktop on Linux, macOS and Windows first; the browser follows on the same code.
