Perspective: WebAssembly Data Grid and Pivot Table for Streaming Datasets

The Problem Perspective Addresses: Interactive Analytics on Large Datasets

Most web-based data visualization tools are built to display a fixed snapshot of data. When the dataset is large enough that filtering, grouping, and pivoting require a query, the usual approach is to round-trip to a server, wait for a result, and re-render. For streaming data sources, that model breaks down because the data is changing continuously.

Perspective addresses this by embedding a query engine directly into the component. Tables can be updated incrementally as new data arrives, and views update in real time without re-running the full query. Reactive joins across multiple tables are also supported, so combining a live feed with a reference table updates the joined view whenever either source changes.

The README describes Perspective as suited for building user-configurable reports, dashboards, notebooks, and embedded analytics applications. The target users are data engineers and frontend developers who need to give end users live, interactive control over how data is presented, not just which chart to display.

The WebAssembly Query Engine: Architecture and Capabilities

The core query engine is written in C++ and compiled to WebAssembly. This means the same engine code runs in the browser without any server round-trips for local data. The README notes a standard build and a 64-bit memory64 build: the memory64 build removes the 4GB address space limit of standard WebAssembly, making it possible to hold datasets larger than 4GB entirely in the browser. For datasets that exceed available memory, OPFS (Origin Private File System) paging is supported in the browser, and memory-mapped files are available when running natively.

The engine handles Apache Arrow, CSV, and JSON as input formats, with full read, write, and streaming support for Apache Arrow. A columnar expression language based on ExprTK allows adding computed columns with expressions evaluated at query time rather than at ingestion.

The same C++ engine is compiled to Python bindings (perspective-python) and Rust bindings (perspective), and wrapped in a Node.js package (@perspective-dev/client). The client API is described in the README as symmetric: the same API connects to an engine running in-process, in a Web Worker, or remotely over WebSocket.

Installing Perspective and Running a First Example

For JavaScript and TypeScript projects, the client package is available on npm:

npm install @perspective-dev/client

For Python projects, the package is on PyPI:

pip install perspective-python

For Rust projects, the crate is published on crates.io as `perspective`. The workspace in the repository contains examples for esbuild, webpack, Vite, and React-based setups under the examples/ directory. Server-side examples cover Python with aiohttp, Starlette, and Tornado, as well as Node.js and Rust with Axum.

For Jupyter users, Perspective ships a JupyterLab widget built on the anywidget framework. The package @perspective-dev/jupyterlab is listed in the repository workspaces. The widget connects the same Python-backed table to an interactive data grid inside a notebook cell.

The React component is packaged separately as @perspective-dev/react. It wraps the Web Component in a React-compatible API, so teams already on React do not need to work with the Custom Element directly.

Virtual Server Connectors: Querying DuckDB, ClickHouse, PostgreSQL, and Polars

Perspective's virtual server feature is a mechanism for connecting the UI directly to an external database engine. When a virtual server is configured for DuckDB, ClickHouse, PostgreSQL, or Polars, Perspective translates the user's drag-and-drop view configuration into native queries for that engine and returns results without moving the data into Perspective's own table format.

The README describes this as requiring no ETL or data copy. For a DuckDB instance with a large local dataset, this means the browser UI can pivot, filter, and group data that never leaves the database. For ClickHouse, the same applies to a remote OLAP database. The Python virtual server modules are listed in the README under perspective.virtual_servers.clickhouse, perspective.virtual_servers.duckdb, perspective.virtual_servers.postgres, and a Polars variant.

JavaScript virtual server modules for DuckDB and ClickHouse are listed in the README's API documentation section. The examples directory includes esbuild-clickhouse-virtual/ and esbuild-duckdb-virtual/ projects. This approach means Perspective's UI becomes a query builder for engines that already handle scale, rather than needing to load data into the WebAssembly engine.

Limitations: Build Complexity and a Fixed Visualization Set

Perspective's build chain is substantial. The repository uses pnpm workspaces, a custom Emscripten toolchain version pinned in package.json (emscripten 4.0.9), a custom Binaryen version, and a Pyodide version, plus Rust and a pinned Rust toolchain in rust-toolchain.toml. The DEVELOPMENT.md file and the Cargo.lock indicate a complex multi-language build. Contributors need the full Emscripten and Rust toolchains to build the WebAssembly module from source.

The component ships a defined set of chart types via a WebGL charting engine. The README describes 15+ chart types plus geographic tile maps. Teams that need custom chart types not in that set must use a different library or render the custom chart alongside Perspective, not inside it.

Perspective's data model requires data to be loaded into a Perspective table or accessed through a virtual server. There is no direct connector to arbitrary REST APIs or GraphQL endpoints. Data ingestion into the table happens through JavaScript code that feeds Arrow, CSV, or JSON, so any custom data source requires a write step in the application.

Perspective vs Apache ECharts: Different Scope and Audience

Apache ECharts is a JavaScript charting library that renders a wide variety of chart types including scatter, line, bar, heatmap, tree, and geographic maps. It is designed for rendering static or periodically refreshed chart data in a web page, with a configuration-object API that describes each chart's series, axes, and styling.

Perspective provides a different abstraction. Rather than configuring individual charts, users configure a query over a table and choose how to display the results. The same table can be viewed as a pivot table, a data grid, or a chart, and the user can switch between views interactively. The query engine handles grouping, filtering, and aggregation at the component level.

ECharts is the better choice when the application needs custom chart types, fine-grained control over chart appearance, or a wide variety of chart forms not in Perspective's set. Perspective is the better fit when the application needs end-user query configuration over live data, especially for grid-style data exploration where pivot tables and real-time updates are core requirements.

Editorial conclusion

Perspective suits teams building interactive analytics dashboards, trading desks, or monitoring tools where the data is large, live, or both. The WebAssembly query engine covers in-browser datasets up to and beyond 4GB with the memory64 build. It is not a general-purpose charting library: it ships a specific set of chart types, a data grid, and geographic tile maps. If a project needs only static charts or custom visualization types that are not in Perspective's set of 15+, a dedicated charting library is the simpler choice. The package is at version 5.5.1, released on 2026-09-18, and the last push to the repository was on 2026-09-25.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. perspective-dev/perspective on GitHub
3. Project website
4. README
5. Releases