# ParaView: a VTK-based desktop application for post-processing simulation data

> ParaView is an open source, multi-platform data analysis and visualization application built on the Visualization Toolkit. It is aimed at engineers and scientists who need to inspect simulation datasets, and this article covers what it does, how to build it from source, and where the documentation stops short.

**Kitware/ParaView** — VTK-based Data Analysis and Visualization Application

- Repository: https://github.com/Kitware/ParaView
- Website: http://www.paraview.org
- Stars: 1,703 · Forks: 493
- Language: C++
- License: BSD-3-Clause
- Published: 2026-08-04 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/kitware-paraview

## What ParaView is for, and who ends up using it

ParaView is a desktop application for analyzing and visualizing data, built on the Visualization Toolkit. The README describes it as open-source, multi-platform, and based on VTK, with a first public release announced in October 2002. The project grew through collaboration between Kitware, Sandia National Laboratories, Los Alamos National Laboratory, the Army Research Laboratory, and other government, commercial, and academic partners.

The audience is narrow and practical. If you have simulation output on disk and need to look at it, slice it, color it by a field, or trace flow through it, ParaView is the kind of tool you reach for. The repository layout supports that reading: there are Adaptors, Plugins, Examples, and a PythonClient example, alongside the core application code. It is not a library you link into a service, and it is not a plotting package for small tabular data. The scale it targets is the one where a spreadsheet stops being useful.

One structural fact matters more than the feature list. The GitHub repository is a mirror. The README states plainly that issues and pull requests on GitHub are not actively monitored, and that the official repository is on GitLab at gitlab.kitware.com/paraview/paraview. If you file a bug in the wrong place, the README's own guidance is to first ask on the ParaView Discourse forum whether the behavior you saw is actually a bug.

## The VTK pipeline underneath the interface

Everything ParaView shows you is produced by a VTK pipeline. A source produces a dataset, filters transform it, and a view renders the result. The repository reflects that split: VTK is vendored as a top-level entry, VTKExtensions holds ParaView-specific pipeline additions, and Remoting sits between the user interface and the server-side pipeline execution. Clients/ holds the application front ends, Qt/ the Qt-based interface layer, and Web/ the web-facing pieces.

That separation is why the same visualization can run locally or against a remote process without rewriting the pipeline. The Remoting directory exists precisely because the client and the data processing are not assumed to live in one process. The Examples directory shows the same idea from the outside: Examples/Catalyst and Examples/Catalyst2 are in-situ examples, Examples/CAVE covers display environments, and Examples/CustomApplications and Examples/Plugins show how the shell can be extended rather than replaced.

If you have used VTK directly, the mental model transfers without much friction. If you have not, the pipeline is the concept worth learning first, because it explains why changing a filter parameter re-executes part of the graph rather than redrawing a static image.

## Building ParaView from source, and a first Python client

The README does not publish binary installers. It gives two build routes. The first is the Getting Started compilation guide at Documentation/dev/build.md, which the README calls the easiest method for beginners and which includes commands to install the needed dependencies for most operating systems. The second is the ParaView Superbuild, hosted at gitlab.kitware.com/paraview/paraview-superbuild, which downloads and builds all of ParaView's dependencies as well as ParaView itself. The README recommends the Superbuild when you need specific options that require building dependencies yourself, and names osmesa and raytracing as examples.

The repository also carries CMakePresets.json and a CMake/ directory, so a configure step starts from a preset rather than from a long hand-written command line. The exact preset names are in that file, not in the README.

Once you have a build, the Python client is the fastest way to drive the pipeline from a script. The repository keeps a worked example under Examples/PythonClient. The README does not reproduce that code, so read the example files in that directory rather than copying a snippet from here; the pattern is to import the client module, connect to a server, and then build sources and views through the session object.

The Examples directory also ships RunExample.cmake, which is the mechanism the project uses to execute its own examples in testing. Reading it is a reasonable way to see how a headless run is expected to be invoked, since the README does not document a command-line entry point of its own.

## Where ParaView is the wrong tool

The most concrete limitation is distribution. There is no install section in the README, no package name, no version, and no supported binary path. The README points to the homepage and to two from-source build routes. Anyone who needs a reproducible, unattended install on a fleet of machines has to solve that themselves, and the Superbuild route in particular means compiling dependencies, which is a long build with its own failure modes.

The second limitation is the issue workflow. The README states that GitHub is a mirror and that issues and pull requests there are not actively monitored. A team that tracks work through GitHub will find its bug reports land nowhere useful. The documented path is the Discourse forum first, to establish expected versus observed behavior, and the GitLab issue tracker second.

Third, ParaView is a visualization application, not a data processing service. Nothing in the README describes an HTTP API, a queue, or a scheduler. If your requirement is to render images on demand inside a web backend, the Web/ directory and the Remoting layer are the relevant pieces, but the README does not document them as a supported server product. Treat that as unexplored ground rather than a feature you can assume.

Finally, interactive visualization does not scale the way batch processing does. The Catalyst examples exist because in-situ analysis is the alternative when writing full timesteps to disk for later inspection becomes the bottleneck. If your dataset is already too large to move, an in-situ path is the architecture to look at, and that is a different design decision than opening files in the desktop application.

## ParaView against writing raw VTK

The honest alternative is VTK itself. ParaView is built on VTK, so the pipeline concepts, the data types, and the filter semantics are the same; what ParaView adds is the application around them. Choosing between the two is a question of who operates the result.

With raw VTK you write a program that constructs the pipeline and renders or writes output. You get full control over execution, you can embed it in a service, and there is no GUI to install. You also write the reader configuration, the camera setup, and the output handling yourself, and every new question about the data becomes another code change. ParaView inverts that: an analyst opens the application, loads the data, and explores interactively, and the Python client lets that exploration be scripted when it needs to be repeated.

The trade is deployment versus iteration speed. A team that needs one fixed rendering path inside a backend service is usually better served by VTK directly. A team that needs to answer questions about data it has not fully characterized yet will spend less time in ParaView, because the pipeline can be rewired without a rebuild. The Examples/CustomApplications and Examples/Plugins directories show the middle ground: extending the ParaView shell rather than abandoning it.

## Licence, forks, and the cost of staying current

ParaView is distributed under the OSI-approved BSD 3-clause License. The README points to Copyright.txt in the repository for details and to a ParaView Licenses page for additional licences. A permissive licence of that kind generally means you can redistribute and modify the software, but the repository bundles third-party components under ThirdParty/, and the README explicitly separates the base licence from additional licences. If you ship ParaView or a derivative, read Copyright.txt and the licences page rather than assuming the BSD 3-clause text covers every file. This is not legal advice; it is a pointer to the two documents the project names.

Upgrade cost is dominated by the build. Because the README offers no packaged install, moving to a newer revision means rebuilding, and if you use the Superbuild, rebuilding dependencies too. That is a recurring cost, not a one-time one, and it is higher for anyone who enabled optional components such as osmesa or raytracing.

On maintenance: the repository is not archived, and the README describes an active collaboration among named institutions. No last-push date and no release information appear alongside this repository, so any statement about how frequently the code changes would be a guess. Check the commit history on the GitLab repository before you rely on a cadence.

The fork question is worth stating plainly. Because GitHub is a mirror, a fork made there is a fork of a mirror. If you intend to contribute a fix, the README directs you to CONTRIBUTING.md and to the official GitLab repository, and it warns that pull requests on GitHub are not actively monitored.

## Conclusion

Adopt ParaView if your work is post-processing simulation output that already exists in a format VTK can read, and you want a desktop application plus a Python client rather than writing raw VTK code. Do not adopt it expecting a hosted service, a managed pipeline, or a supported Windows installer published from this repository; the README points at the website and at a from-source build instead. Before committing, verify two things: that your data format is readable without writing a custom reader, and that the build path you choose (the Getting Started compilation guide or the Superbuild) produces the optional components you need, since the README states the Superbuild is the route for osmesa and raytracing.

## FAQ

### What is ParaView used for?

ParaView is an open-source, multi-platform data analysis and visualization application built on the Visualization Toolkit. It is used to analyze and visualize data, and the repository includes adaptors, plugins, and in-situ examples under Examples/Catalyst and Examples/Catalyst2.

### Is ParaView software free?

ParaView is distributed under the OSI-approved BSD 3-clause License, and the README points to Copyright.txt for details and to a ParaView Licenses page for additional licences. Commercial support and training are offered separately by Kitware.

### How to install ParaView on Windows?

The README does not give a Windows install procedure. It lists two build routes: the Getting Started compilation guide at Documentation/dev/build.md, which includes dependency commands for most operating systems, and the ParaView Superbuild, which builds all dependencies plus ParaView itself.

### Does ParaView use VTK?

Yes. The README describes ParaView as a data analysis and visualization application based on the Visualization Toolkit, and VTK appears as a top-level entry in the repository.

### How to use ParaView in Python?

The repository includes a Python client example under Examples/PythonClient. The README does not document the Python API itself, so the example directory is the place to read the working code.

### How to install ParaView on Linux?

The README gives no per-platform install steps. It points to the Getting Started compilation guide at Documentation/dev/build.md, which it says includes commands to install the needed dependencies for most operating systems, and to the ParaView Superbuild for building dependencies yourself.

## Sources

- [Official documentation](http://www.paraview.org)
- [Official README](https://github.com/Kitware/ParaView#readme)
- [Project repository](https://github.com/Kitware/ParaView)

---

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