# Inviwo: a visual programming framework for turning volumes and data into pictures

> Inviwo is a C++ and Python visualization framework where a processing pipeline is assembled by dragging processors onto a canvas and wiring ports between them. It targets scientists working with medical imaging and simulation output, and its selling point is that a graph you build by mouse is a graph you can extend with real code.

**inviwo/inviwo** — Inviwo - Interactive Visualization Workshop

- Repository: https://github.com/inviwo/inviwo
- Stars: 531 · Forks: 153
- Language: C++
- License: BSD-2-Clause
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/inviwo-inviwo

## A pipeline you assemble by dragging instead of typing

Inviwo is described as a visualization framework designed for scientists, researchers and developers who need to transform complex data into meaningful visual representations, whether that is medical imaging, scientific simulations or data analysis.

The mechanism is a visual programming interface. You build a data processing pipeline by connecting components in a visual graph, and the readme frames the goal as rapidly prototyping complex data processing workflows. The visual programming environment is a first class part of the product, not a diagram tool bolted onto a library, and that distinction matters for how you evaluate it.

The core vocabulary is four terms, and they are worth learning in order because they nest.

A processor is a fundamental building block that performs a specific data processing or visualization task. A port is a connection point on a processor that allows data to flow in, as an inport, or out, as an outport. A property is a configurable parameter of a processor that lets users control its behaviour, such as visualization parameters, numerical values or algorithm settings. A module is a collection of related processors, data structures and utilities that extends the functionality for a specific domain or purpose.

The example the readme gives is a data reader processor that loads a volume dataset through its outport, which connects to the inport of a visualization processor that renders the volume, and finally connects to a canvas processor that displays the result. Those three processors could come from different modules, for instance the base module for data I/O, the OpenGL module for rendering, and a specialised module for particular visualization techniques.

So the pipeline is a graph of typed connections, and the module system is what makes it extensible. Dragging and connecting builds the graph; adding modules and writing your own processors extends what the graph can contain.

## Python for speed, C++ when the frame budget matters

The two-language story is the second defining feature, and the readme is specific about which language suits which task.

The documentation says that Create Python processors is perhaps the quickest way of extending the Inviwo functionality, while Create C++ processors is the most flexible way of extending it. The feature list puts it as develop processors in Python for rapid prototyping or C++ for performance-critical tasks.

That is a sensible split for a scientific visualisation tool. A researcher exploring a dataset does not want to write a rendering application to find out whether a transfer function looks right. A processor that loads a volume and applies a colour map is a few lines of Python, plugs into the graph immediately, and can be visualised in the same window as everything else. When the same idea turns out to be in the inner loop of an interactive render and the frame rate drops, the same processor is rewritten in C++ and dropped into the same graph, because the port contract does not change.

The interface supports this because the visual programming interface makes it easy to construct pipelines by dragging and connecting processors, while the modular architecture allows you to extend the system with new processors and capabilities through additional modules.

The other thing Python buys you is the application embedding path. The readme states that the Inviwo framework and data processing pipelines built using the Inviwo network editor can be integrated into your application, and it names two projects that use the framework under the hood: Visual Neuro, a visual analysis tool for understanding cohorts of brain imaging and clinical data, and ENVISIoN. So the framework is not only an application you run, it is something you can put inside your own tool.

That is the strongest argument for Inviwo over a plain plotting library for scientific work: the pipeline you designed interactively can become part of a product.

## Debugging by hovering over a port

The feature list has an entry that does not appear in most framework descriptions: visual debugging, where you inspect intermediate results by hovering over data ports, which the readme says simplifies the debugging process.

This is the kind of detail that changes how a tool feels in use. A pipeline with fifteen processors has fifteen intermediate states, and the usual way to see them is to insert print statements, log to a console and read text. Hovering over a port and seeing the data that is actually flowing through it is faster and, more importantly, it shows the data as it is rather than as your logging code represents it.

That matters more in a visual framework than in a normal application, because the intermediate results are often images or volumes. A screenshot in a hover panel is a far more direct diagnostic than a summary of array dimensions.

The other capability in the same list, easy parallel computing, is described as leveraging parallel processing on CPUs and GPUs with simplified abstractions to boost performance. The topic tags for the repository include opencl and glsl, so the GPU side is real, and the C++ path is where that lives, which is another reason the two-language split is not arbitrary.

There is also a data format angle. The framework supports numerous data formats including HDF5, DICOM, NIfTI, RAW volumes and common image formats. DICOM and NIfTI are the two that dominate medical and neuroimaging research, so the format coverage is aimed squarely at the audience the introduction names. The readme says numerous rather than giving an exhaustive list, so if your format is unusual you should check the documentation rather than assume.

## Installing the precompiled build, and what the source build costs

There are two ways to get started, and the readme is direct about their relative merits.

The precompiled version is the easiest way to get started. You download the latest precompiled version for your platform from the releases page, extract the archive and run the Inviwo application. The readme notes that this route lets you use the visual interface and develop new functionality using Python, which is a useful framing: the binary is not a stripped down demo, it is the full application with the Python extension path available.

Then there is the Getting started window, which lets you browse examples, and the readme names a specific one: the Mandelbrot set showcasing a processor built using Python. That is a good first example to run, because it demonstrates the point of the framework in a single image rather than a table of numbers.

Building from source is the most flexible option and allows you to develop new functionality and applications in both C++ and Python, and the readme sends you to the build instructions page on the project site rather than reproducing them.

What the repository layout tells you about that build. There is a CMakeLists.txt and a CMakePresets.json, so it is a CMake project with presets. There is a vcpkg.json, which is how a C++ project declares its C++ dependencies on Windows. The ext/ directory holds external code, and modules/ holds the module tree that the extension model depends on. A Jenkinsfile is present alongside the GitHub Actions workflow, which tells you the continuous integration runs in both places.

The Python side has its own requirements file, and it is short: numpy, Sphinx, sphinx-rtd-theme and recommonmark. Sphinx and the documentation theme are there to build the API documentation, and numpy is the numeric dependency the Python processors use. The build instructions page is where the environment setup is documented, and the docs/ directory in the repository is where the documentation source lives.

## Commercial use without a licence negotiation

The licensing is one of the more consequential lines in the readme, and it is worth reading carefully.

The framework is freely available for commercial use under the Simplified BSD License, and the licence field on the repository lists BSD-2-Clause with a BSD badge in the header. That matters for a scientific framework in a specific way. Research tools get embedded in commercial products, in medical device research, in simulation tools sold to industry, and a copyleft licence or a non commercial clause would stop that immediately. The Simplified BSD licence asks for attribution and nothing more.

Other things the readme lists in the same block are cross-platform, running on Windows, Linux and Mac OS X, easily extendable through inclusion of external modules and applications, integrated with a GUI for rapid prototyping of data processing pipelines, and development in Python or C++.

The repository also carries a CITATION.cff file, an AUTHORS file and a CHANGELOG.md, and the readme points at the changelog for information on new key functionalities and breaking changes. That last one is the file to read before you upgrade. A visualisation framework that changes its processor API between versions costs you work, and the readme tells you where to find out, which is more than most projects do.

For an academic or industrial research group, the combination of a permissive licence, a Python extension path and a C++ performance path is the argument. Everything else in this review is about whether the framework fits the shape of your problem.

## Where Inviwo is the wrong tool

There are three cases where this is the wrong choice, and they are about scale and shape rather than quality.

The first is a one off plot. If you need to make a chart of an array, reach for a plotting library. Inviwo is an application with a GUI, an OpenGL rendering context, a module system and a build. None of that is needed to draw a line.

The second is a production service that only needs to read data and write an image. A framework whose main interaction model is a human dragging processors around a canvas is optimised for exploration. If the requirement is a headless service that takes a request and returns a rendered frame with no one watching, the visual programming interface is overhead, and the readme's framing of the framework as something to integrate into your application does not make that case disappear.

The third is a team that does not want a C++ toolchain. Building from source pulls in CMake, a C++ compiler, vcpkg on Windows, and a module tree, and the dependency stack in ext/ is not something you can audit at a glance. The precompiled download avoids all of it, but then you are limited to the Python extension path for anything you write yourself.

On the alternative, the comparison with a general purpose scientific Python stack is instructive. A notebook with numpy and a plotting library gives you a fast loop for exploring an array, and it is the right tool for most analysis. Inviwo differs in three specific ways. It is a graph rather than a script, so the dataflow is explicit and re-arrangeable. It is interactive in the rendering sense, so you can change a parameter and see the volume re-render, which is how you find a good transfer function. And it is a C++ framework with Python bolted on at the edges rather than the other way around, so a hot path can be made fast without leaving the tool.

A second alternative is writing a dedicated OpenGL or OpenCL application for one specific visualisation. The trade there is total control and total responsibility: you own the render loop, the camera, the interaction, the data loading and the UI, and you get exactly the pipeline you need and nothing else. Inviwo gives you a working pipeline, a module ecosystem, a debugger that shows you the data at each step and a Python path for experiments, and the price is that your application is built inside a framework whose abstractions you did not choose.

The choice comes down to whether you want to explore many visualisations of the same kind of data, in which case a graph and a visual debugger pay for themselves quickly, or build one specific tool, in which case a framework is the wrong shape.

## Conclusion

Inviwo suits a researcher who needs to look at volume or image data interactively and wants to prototype a pipeline without writing a rendering application, and it does not suit someone who wants a small library to call from a script, since this is a full application with a GUI, an OpenGL context and a build step. Before you adopt it, confirm your data formats are covered, because the readme lists HDF5, DICOM, NIfTI, RAW volumes and common image formats rather than an exhaustive format list, and check the CHANGELOG.md file, since the framework carries breaking changes between versions.

## FAQ

### What is Inviwo?

Inviwo is a C++ and Python visualization framework for scientists and developers, where data processing pipelines are built by connecting processors through ports in a visual programming interface. It targets medical imaging, scientific simulation and data analysis work.

### How do I install Inviwo?

Download the latest precompiled build for your platform from the releases page, extract the archive and run the application, or build from source with CMake, which the readme says is the most flexible option and which allows extending the framework in both C++ and Python.

### Can I extend Inviwo with Python?

Yes. The documentation describes creating Python processors as perhaps the quickest way to extend the functionality, with C++ processors being the most flexible way, and the precompiled build supports developing new functionality using Python.

### Which data formats does Inviwo support?

The readme lists numerous data formats including HDF5, DICOM, NIfTI, RAW volumes and common image formats. It does not give an exhaustive list, so the documentation site is the place to check an unusual format.

### What licence is Inviwo released under?

The framework is freely available for commercial use under the Simplified BSD License, and the licence on the repository is recorded as BSD-2-Clause.

## Sources

- [inviwo/inviwo on GitHub](https://github.com/inviwo/inviwo)
- [Issues](https://github.com/inviwo/inviwo/issues)
- [License: BSD-2-Clause](https://github.com/inviwo/inviwo/blob/master/LICENSE)
- [README](https://github.com/inviwo/inviwo/blob/master/README.md)
- [Releases](https://github.com/inviwo/inviwo/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/inviwo-inviwo