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.
Online WebGL Demo | Online Documentation
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.
Support
