Helix Vizforge - Unity Charts and Dashboards

Build interactive charts, graphs, dashboards, financial panels, scientific plots, telemetry overlays and world-space data visualizations without stitching together separate chart systems.

Helix Vizforge is a complete charting and data-visualization framework for Unity. It combines 28 core 2D chart generators, financial and scientific analysis, dashboards, live telemetry and procedural 3D charts with one typed data model and one rendering pipeline.

Use the same Dataset, scales, themes and interactions for a line chart on a Canvas HUD, a candlestick panel in a trading simulation, a live FPS graph, a cross-filtered analytics dashboard or a 3D surface plot placed directly in your scene.

|

Try it before you buy it.

The interactive WebGL showcase is built from the actual asset. Its seventeen hands-on modules let you:

• Switch between chart types

• Change themes at runtime

• Stream live telemetry

• Cross-filter a dashboard

• Pan and zoom with real hit testing

• Export a PNG report

• Load your own CSV through the browser's file picker

Nothing in the showcase is mocked. Every module uses the public API included in the package.

One charting pipeline, three rendering backends

A chart is converted into a backend-neutral DrawList, then submitted to any of three render surfaces:

• UGUI — UGuiChartSurface, implemented as a MaskableGraphic, for Canvas HUDs, menus and application panels.

• UI Toolkit — VizforgeChartElement, rendered through generateVisualContent and MeshGenerationContext, with geometry chunking for the 16-bit mesh-index limit.

• World-space and 3D — WorldSpaceChartSurface, using procedural MeshFilter and MeshRenderer output for in-scene visualizations and 3D chart meshes.

You do not need separate datasets or chart definitions for each UI system. The Render Backends demo module draws one chart through all three backends at the same time from a single geometry pass.

Charts and graphs

Helix Vizforge includes 28 core 2D chart generators:

• Line, area, spline, step and sparkline charts

• Scatter plots

• Vertical and horizontal bar charts

• Stacked and grouped bars

• Waterfall and funnel charts

• Pie and donut charts

• Radar and polar charts

• Sunburst charts

• Histograms

• Box plots and violin plots

• Heatmaps

• Gauges and progress indicators

• Parallel-coordinates plots

• Treemaps and Sankey diagrams

• Timeline and Gantt charts

A dedicated procedural-mesh path adds:

• 3D bar charts

• 3D scatter plots

• 3D surface plots

Financial visualization

Create financial and trading interfaces with:

• Candlestick and OHLC charts

• Volume views

• Simple and exponential moving averages

• Bollinger bands

• RSI

• MACD

All indicators are calculated inside the package.

Scientific analysis

The package includes:

• Linear, polynomial, exponential, power and logarithmic least-squares fitting

• Live R² results

• Moving-average smoothing

• Savitzky-Golay smoothing

• FFT power spectra

• Marching-squares contour generation

• Confidence bands and error bars

• K-means clustering

• Linear and exponential forecasting

• Descriptive statistical summaries

Dashboards and business intelligence

Build multi-panel dashboards with chart and label widgets arranged in serializable grid layouts.

Dashboard features include:

• Layout serialization to JSON

• Cross-filtering

• Pivot tables

• KPI scorecards

• Hierarchical drill-down

• Funnel analysis

• Cohort-retention analysis

Cross-filtering is applied through GeometryContext.RowFilter, so excluded rows are removed before tessellation instead of being drawn and hidden afterward.

Live telemetry and runtime graphs

A fixed-capacity ring-buffer TimeSeries and TelemetryHub support continuously updating charts without unbounded data growth.

Included telemetry sources cover:

• FPS

• Frame time

• Managed memory

You can add custom sources through ITelemetrySource, define threshold alerts and display incoming samples with the live-line generator.

Data import, transformation and reuse

The typed columnar Dataset / DataSeries model supports:

• Number

• Time

• Category

• Boolean

• Text

• Color

• Vector3

Create data through inline builders or reusable DatasetAsset files, import and export CSV or JSON, or load remote text through UnityWebRequest.

Built-in transformations include:

• Filter

• Sort

• Map

• Bin

• Aggregate

• Join

Available aggregate operations include Sum, Mean, Min, Max, Count, Median, First and Last.

The CSV importer supports headers, type inference, quoted fields, embedded delimiters, embedded newlines, escaped quotes, ragged rows, CRLF and LF line endings, blank trailing lines and delimiter auto-detection.

Scales, axes and themes

Included scale types:

• Linear

• Logarithmic

• Symmetric logarithmic

• Time

• Band/category

Each scale drives its own automatic tick formatting.

Six included theme presets provide:

• Dark

• Light

• Scientific

• Financial

• High contrast

• Color-blind-safe, Okabe-Ito-style colors

The theming showcase includes a live WCAG contrast readout, and themes can be changed while the application is running.

Interaction

The shared chart pipeline supports runtime interaction across the rendering backends, including:

• Pan and zoom

• Real hit testing

• Dashboard cross-filtering

• Hierarchical drill-down

Because interaction operates against the shared data and geometry model, it does not need to be rebuilt separately for each individual chart type.

Export and reporting

Export data and visualizations as:

• CSV

• JSON

• SVG

• PNG

SVG export produces true vector output.

PNG output is rasterized entirely on the CPU, without GPU readback, so it can run in headless CI environments. ReportComposer can combine multiple panels into one titled report.

Editor workflow

The package includes:

• Chart Wizard editor window

• Custom inspector for ChartView

• Custom inspector for DatasetAsset

• Custom inspector for ThemeAsset

• Assets/Create menu entries

• GameObject creation menu

• Sample-scene generator

• Asmdef lint and compile-check helpers for CI

Both inspector-driven and scripting workflows are supported. The included documentation covers a no-code setup path as well as the full public API.

Evidence you can run yourself

Approximately 470 automated tests are included across edit-mode, editor and play-mode assemblies. They run locally in Unity's Test Runner.

The last recorded full batchmode run completed with:

• 451/451 edit-mode tests passing

• 14/14 play-mode tests passing

• Zero compile errors

• Clean assembly-definition lint

Published performance floor

Tests/EditMode/PerformanceTests.cs measures the backend-neutral CPU pipeline that converts source data into a DrawList.

Generation scales linearly with point count, and a dedicated regression test guards against super-linear behavior.

The published measurements were deliberately taken in Editor batchmode under Mono, using -nographics and without release optimization. They are presented as a conservative performance floor and regression guard rather than an optimized best-case benchmark.

No third-party runtime libraries or native binaries

The package does not require:

• Newtonsoft JSON

• External mathematics libraries

• Native plugins

• DLLs

• P/Invoke

• External web services

• API keys

The JSON parser, CSV parser, FFT, curve fitting, clustering, technical indicators and CPU PNG rasterizer are implemented in the package in managed C#.

That managed implementation is also what allows the interactive demo to build to WebGL.

Verified builds

The following configurations have been built and verified:

• Unity 6000.0.62f1 on Windows

• Interactive WebGL demo

The code is platform-agnostic managed C#, but platforms not listed above have not been built on the development machine and are therefore not claimed as verified.

Known limitations

Stated up front, because discovering them after purchase is worse.

• UGUI vertex ceiling. A single UGUI mesh is limited to roughly 65,000 vertices, corresponding to approximately 16,000 line points in a typical line chart. For larger geometry, use the UI Toolkit or world-space backends, which chunk their output.

• GPU-dependent showcase modules. The 3D charts and UI Toolkit render-backend pane use RenderTexture output. They compile and run under headless -nographics, but cannot produce captured pixels without a GPU.

• PNG-export text. CPU PNG export uses a compact built-in 5×7 bitmap font. KPI and pivot labels can become crowded at small sizes. Use SVG export when crisp, scalable text is required.

• Render pipelines. URP and the Built-in Render Pipeline are supported. URP is recommended for world-space charts, with documented Built-in material fallbacks. HDRP has not been tested and is not claimed.

• No Burst or Jobs acceleration. The package reserves an assembly for future acceleration work, but the shipped code path is entirely managed. The published performance measurements represent the actual shipped path.

• Verified platforms. Windows with Unity 6000.0.62f1 and WebGL are the verified targets. Other platforms have not been built on the development machine.

Requirements

Unity 6000.0 or newer.

UGUI is used for the default Canvas workflow. UI Toolkit and world-space rendering are alternative backends.

URP is recommended for world-space charts. The project references URP 17.0.4.

The Input System package is used by the interactive demo, which creates its own input module at runtime.

Samples and documentation

Included content:

• Twelve sample scenes

• One seventeen-module interactive showcase scene

• A single searchable HTML manual

The manual covers installation, quick starts, the complete chart catalog, all rendering backends, scales, datasets, themes, the no-code workflow, scientific and financial analysis, dashboards and BI, telemetry, export, the scripting API, troubleshooting and frequently asked questions. AI-GENERATED CONTENT DISCLOSURE This package was built with AI-assisted development tools. Primarily Claude Code for the C# implementation, with a smaller amount of assistance from GPT-based models via Codex. All generated code was reviewed, edited and integrated by hand rather than shipped as produced. The written documentation and store copy were drafted with AI assistance and edited by hand.

Features

• 35+ chart types: line, bar, pie, radar, heatmap, Sankey, Gantt, candlestick, box plot, contour, 3D bar/scatter/surface and more.
• Three render backends: UGUI, UI Toolkit and world-space meshes from one pipeline.
• Typed data model: datasets, CSV/JSON import and export, remote loading, filter/sort/bin/aggregate/join.
• Live telemetry: ring-buffer time series for continuously updating charts.
• Interaction: pan, zoom, tooltips, selection and legends.
• Dashboards and BI, financial and scientific analysis, themes and palettes.
• No-code and scripting workflows, about 470 automated tests and full C# source.

Requirements

• Unity 6.0 or newer — built with Unity 6000.0.62f1.
• Built-in Render Pipeline or URP (URP recommended for world-space charts).

Instructions

Complete documentation is included in the package itself, and the same guide is available online:

Helix Vizforge documentation