[Installation] [Usage] [User guide] [Gallery]
⚡️ Datoviz is an open-source, cross-platform, high-performance rendering library for scientific data visualization making extensive use of the graphics processing unit (GPU).
Up to 10,000x faster than matplotlib, it delivers highly efficient high-quality GPU rendering of 2D and 3D graphical primitives—markers, paths, images, text, meshes, volumes, and more—that scale to millions of elements. Datoviz also supports graphical user interfaces (GUIs) for interactive visualization.
Built from the ground up with performance in mind, Datoviz is written primarily in C and C++, leveraging the Khronos Vulkan graphics API. It offers a C API, low-level Python bindings via ctypes, and a higher-level, idiomatic Python API 🐍.
Written by one of the original creators of VisPy, a GPU-based Python scientific visualization library, Datoviz aims to serve as the default backend for the upcoming VisPy 2.0.
The library is lightweight with minimal dependencies: mostly Vulkan, GLFW for windowing, and Dear ImGui for GUIs.
Warning
Datoviz is a young library. The API is stabilizing, but breaking changes may still occur as the project evolves with broader usage.
- 📊 2D visuals: antialiased points, markers, line segments, paths, text, images
- 📈 2D axes
- 🌐 3D visuals: meshes, volumes, volume slices
- 🌈 150 colormaps included (from matplotlib, colorcet, MATLAB)
- 🖱️ High-level interactivity: pan & zoom for 2D, arcball for 3D (more later)
- 🎥 Manual control of cameras: custom interactivity
- 𓈈 Figure subplots (aka "panels")
- 🖥️ GUIs using Dear ImGui
Datoviz does not use high-level plotting functions like plot(), scatter(), or imshow(). Instead, it exposes flexible visual primitives—markers, images, meshes, and more—that can be added to a scene and customized directly with data. This approach offers fine-grained control and high performance, while remaining concise enough for quick plots.
A higher-level plotting interface is under development as part of VisPy 2.0, which will use Datoviz as its rendering backend. An intermediate layer called GSP (Graphics Specification Protocol) will provide a backend-agnostic API for declarative plotting.
Matplotlib is the gold standard for static, publication-quality figures, with a mature, feature-rich API. But it's not optimized for interactivity or large datasets.
Datoviz, in contrast, is a younger, GPU-based library designed for fast, interactive visualization. It lacks Matplotlib’s high-level API but excels at rendering millions of points in real time.
Use Matplotlib for polished static plots, Datoviz for responsive data exploration.
The figure below shows a preliminary performance benchmark comparing Datoviz and Matplotlib on an interactive 2D scatter plot, with increasing numbers of points and a simulated zoom interaction (on a high-end Linux desktop PC):
In this benchmark, Datoviz outperforms Matplotlib by a factor of up to 10,000×, maintaining interactive framerates even with millions of points. Matplotlib, in contrast, becomes sluggish or fails entirely as the dataset size increases.
Datoviz is lighter, simpler, and easier to install than VTK. It compiles in seconds, has minimal dependencies, and focuses exclusively on real-time rendering of visual primitives. Unlike VTK, it does not include data file I/O (except minimal test loaders like .obj), computational geometry, or data processing.
VTK is a powerful, heavyweight toolkit for 3D visualization, simulation, and scientific computing workflows. In contrast, Datoviz is designed for fast, high-quality 2D and 3D rendering.
The current version is v0.3.x This release introduces major updates over v0.2, including 2D axes and a new Pythonic API.
Looking ahead, the upcoming v0.4 release (2026) will focus on foundational improvements to the low-level engine, paving the way for the following key features in future versions:
- 🧊 Correct transparency in 3D mesh and volume rendering
- ✨ Multisample anti-aliasing (MSAA)
- 🎯 Object picking
- 📈 Nonlinear coordinate transforms
- ⚡ CUDA interoperability
- 🧮 Vulkan compute shaders (similar to CUDA kernels)
- 🖌️ Dynamic and customizable shaders
- 🎛️ Combined GPGPU compute and graphics workflows
- 🔗 GPU memory sharing across visuals
- 🐍 IPython integration
- 🖥️ Qt backend support
- 🌐 WebGPU backend
-
Supported operating systems:
- Linux x86_64 (e.g. Ubuntu 22.04 or later, as the Linux build requires glibc 2.34+)
- macOS 12 or later (x86_64 and arm64, i.e. Apple silicon M1–M4)
- Windows 10 or later (x86_64)
-
Python environment:
- Python 3.8+ (64-bit)
- NumPy
- requests
- platformdirs
-
Up-to-date graphics drivers with Vulkan support (most integrated or dedicated GPUs from the last ten years are supported)
pip install datovizThis installs a Python wheel that includes the C library, precompiled for your system.
If the installation fails, you may need to build from source or open an issue to request support for your configuration.
Nightly builds are automatically generated from the dev branch via GitHub Actions. These builds contain the latest experimental features and bug fixes that have not yet been released.
Warning
Nightly wheels are untested and may be unstable. Use at your own risk, and please report issues if you encounter any problems.
You can find the latest builds on the Nightly Release Page.
Each wheel file is tagged by platform (e.g. manylinux, macosx, win_amd64) and build date (devYYYYMMDD).
Here’s a simple 2D scatter plot example with axes in Python, displaying points with random positions, colors, and sizes.
import numpy as np
import datoviz as dvz
n = 1000
x = np.random.normal(scale=0.2, size=n)
y = np.random.normal(scale=0.2, size=n)
color = np.random.randint(size=(n, 4), low=100, high=240, dtype=np.uint8)
color[:, 3] = 255
size = np.random.uniform(low=10, high=30, size=n)
app = dvz.App(background='white')
figure = app.figure(800, 600)
panel = figure.panel()
xmin, xmax = -1, +1
ymin, ymax = -1, +1
axes = panel.axes((xmin, xmax), (ymin, ymax))
visual = app.point(
position=axes.normalize(x, y),
color=color,
size=size,
)
panel.add(visual)
app.run()
app.destroy()
- 📖 User guide
- 🐍 Examples
- 📚 API reference
- 🏛️ Architecture overview
- 🏗️ Build instructions
- 👥 Contributors instructions
- 🛠️ Maintainers instructions
Datoviz builds on more than a decade of open-source GPU-based scientific visualization work:
-
2012 — Developers of several GPU visualization libraries (Galry, Glumpy, pyqtgraph, visvis) joined forces to create VisPy, a high-performance OpenGL-based visualization library for Python.
-
2015 — The Vulkan API was introduced as a modern low-level successor to OpenGL, inspiring early ideas for a future visualization library built on Vulkan.
-
2019 — Cyrille Rossant, a VisPy cofounder, began experimenting with Vulkan as the foundation for a new graphics engine tailored to scientific visualization.
-
2021 — The first experimental release of Datoviz v0.1 laid the foundation for future development. That same year, a Chan Zuckerberg Initiative (CZI) grant to VisPy helped support the ecosystem.
-
2024 — Datoviz v0.2 was released with a full redesign. It introduced a modular architecture focused on stability and extensibility, paving the way for cross-platform rendering (including WebGPU) with support from a second CZI grant.
-
2025 — Datoviz v0.3 added 2D axes, a more Pythonic API, and core improvements in usability and flexibility.
Datoviz remains closely tied to VisPy and is being developed by one of its original authors. As part of the VisPy 2.0 initiative (led by Cyrille Rossant and Nicolas Rougier, two of the original creators of VisPy), Datoviz will act as a low-level backend beneath a unified scientific visualization layer called the Graphics Server Protocol (GSP), enabling frontends to target multiple renderers (Datoviz, Matplotlib, etc.).
The long-term vision is to enable high-performance 2D/3D scientific visualization across platforms (desktop, web, cloud) and languages (C/C++, Python, Julia, Rust).
See the contributing notes.
See the MIT license.
Datoviz is developed by Cyrille Rossant at the International Brain Laboratory, a global consortium of neuroscience research labs.
Datoviz is supported by:
Wellcome Trust
Simons Foundation
Chan Zuckerberg Initiative, through the Essential Open Source Software for Science program
- Khronos Group (2025). Datoviz: Ultra-fast, high-performance GPU scientific visualization library built on Vulkan
- Rossant, C. & Rougier, N. (2021). Datoviz: A GPU Scientific Visualization Library Based on Vulkan. 2021 IEEE Visualization Conference (VIS).
- Rossant, C. (2015). A compiler for data visualization
- Campagnola, L., Klein, A., Larson, E., Rossant, C., & Rougier, N. P. (2015, July). VisPy: harnessing the GPU for fast, high-level visualization. In Proceedings of the 14th Python in Science Conference.
- Rougier, N. P. (2014). Antialiased 2d grid, marker, and arrow shaders. Journal of Computer Graphics Techniques, 3(4), 52.
- Rougier, N. P. (2013). Shader-based antialiased dashed stroked polylines. Journal of Computer Graphics Techniques, 2(2), 91-107.
- Rougier, N. P. (2013). Higher quality 2D text rendering. Journal of Computer Graphics Techniques, 2(1), 50-64.
