Go to file
2024-06-04 16:46:23 -04:00
.github docs: update gitlab links to include /-/ component 2020-05-26 14:48:49 -04:00
.gitlab/ci ci,ascent: remove ascent build 2024-05-03 08:39:20 -04:00
benchmarking Fix deprecation warning from Google benchmark 2024-05-13 08:20:44 -06:00
CMake Merge topic 'fix-uploading-vtkm-perf-test' 2024-06-03 14:18:01 -04:00
config cmake: update vtkm.pc and vtkm_config.mk file 2023-09-11 14:27:30 -04:00
data update baseline images 2024-02-08 11:04:15 -06:00
docs Merge topic 'obsolete-thrust-patch' 2024-06-04 16:46:23 -04:00
examples Compute volume and select top volume branches 2024-05-17 14:16:50 -07:00
tutorial Deprecated vtkm::filter::FilterField 2024-02-12 08:13:19 +09:00
Utilities Fix issue with nested script strings in CI reproduce script 2024-02-21 16:43:59 -05:00
vtkm Merge topic 'obsolete-thrust-patch' 2024-06-04 16:46:23 -04:00
vtkmstd Have VTKM_IS_TRIVIAL* macros show types better 2021-04-02 07:37:26 -06:00
.clang-format clang-format: update configuration for 9.0 2020-08-24 11:47:55 -04:00
.gitattributes Add VTK-m User's Guide to source 2023-10-17 11:31:27 -04:00
.gitignore initial implementation of ANARI rendering support 2023-08-30 15:52:48 -05:00
.gitlab-ci.yml ci,ascent: remove ascent build 2024-05-03 08:39:20 -04:00
.hooks-config hooks: add hook chains for development checks and LFS 2020-04-02 12:51:43 -04:00
.kitware-release.json CI: adds .kitware-release.json 2021-05-24 18:26:39 -04:00
.lfsconfig LFS: Set lfs.url upon the origin url 2021-06-24 13:26:40 -04:00
.readthedocs.yaml update readthedocs-sphinx-search 2024-02-14 12:03:42 -05:00
CMakeLists.txt Minor fixes for distributed contour tree example 2024-05-10 15:09:03 -07:00
CONTRIBUTING.md Update file CONTRIBUTING.md 2023-05-24 20:02:26 -04:00
CTestConfig.cmake conslidate the license statement 2019-04-17 10:57:13 -06:00
CTestCustom.cmake.in perftest: add benchmark build 2022-10-03 13:21:09 -04:00
LICENSE.txt Add VTK-m User's Guide to source 2023-10-17 11:31:27 -04:00
README.md Merge topic 'remove-cxx11-references' 2023-02-24 11:40:27 -05:00
version.txt release: update version and License 2023-08-18 16:17:19 -04:00

GitLab tag
Spack version


VTK-m is a toolkit of scientific visualization algorithms for emerging processor architectures. VTK-m supports the fine-grained concurrency for data analysis and visualization algorithms required to drive extreme scale computing by providing abstract models for data and execution that can be applied to a variety of algorithms across many different processor architectures.

You can find out more about the design of VTK-m on the VTK-m Wiki.

Learning Resources

  • A high-level overview is given in the IEEE Vis talk "VTK-m: Accelerating the Visualization Toolkit for Massively Threaded Architectures."

  • The VTK-m Users Guide provides extensive documentation. It is broken into multiple parts for learning and references at multiple different levels.

    • "Part 1: Getting Started" provides the introductory instruction for building VTK-m and using its high-level features.
    • "Part 2: Using VTK-m" covers the core fundamental components of VTK-m including data model, worklets, and filters.
    • "Part 3: Developing with VTK-m" covers how to develop new worklets and filters.
    • "Part 4: Advanced Development" covers topics such as new worklet types and custom device adapters.
  • A practical VTK-m Tutorial based in what users want to accomplish with VTK-m:

    • Building VTK-m and using existing VTK-m data structures and filters.
    • Algorithm development with VTK-m.
    • Writing new VTK-m filters.
  • Community discussion takes place on the VTK-m users email list.

  • Doxygen-generated reference documentation is available for both:


There are many ways to contribute to VTK-m, with varying levels of effort.


VTK-m Requires:

  • C++14 Compiler. VTK-m has been confirmed to work with the following
    • GCC 5.4+
    • Clang 5.0+
    • XCode 5.0+
    • MSVC 2015+
    • Intel 17.0.4+
  • CMake
    • CMake 3.12+
    • CMake 3.13+ (for CUDA support)

Optional dependencies are:

  • Kokkos Device Adapter
  • CUDA Device Adapter
  • TBB Device Adapter
  • OpenMP Device Adapter
    • Requires a compiler that supports OpenMP >= 4.0.
  • OpenGL Rendering
    • The rendering module contains multiple rendering implementations including standalone rendering code. The rendering module also includes (optionally built) OpenGL rendering classes.
    • The OpenGL rendering classes require that you have a extension binding library and one rendering library. A windowing library is not needed except for some optional tests.
  • Extension Binding
  • On Screen Rendering
    • OpenGL Driver
    • Mesa Driver
  • On Screen Rendering Tests
  • Headless Rendering

VTK-m has been tested on the following configurations:c

  • On Linux
    • GCC 5.4.0, 5.4, 6.5, 7.4, 8.2, 9.2; Clang 5, 8; Intel 17.0.4; 19.0.0
    • CMake 3.12, 3.13, 3.16, 3.17
    • CUDA 9.2, 10.2, 11.0, 11.1
    • TBB 4.4 U2, 2017 U7
  • On Windows
    • Visual Studio 2015, 2017
    • CMake 3.12, 3.17
    • CUDA 10.2
    • TBB 2017 U3, 2018 U2
  • On MacOS
    • AppleClang 9.1
    • CMake 3.12
    • TBB 2018


VTK-m supports all majors platforms (Windows, Linux, OSX), and uses CMake to generate all the build rules for the project. The VTK-m source code is available from the VTK-m download page or by directly cloning the VTK-m git repository.

The basic procedure for building VTK-m is to unpack the source, create a build directory, run CMake in that build directory (pointing to the source) and then build. Here are some example *nix commands for the process (individual commands may vary).

$ tar xvzf ~/Downloads/vtk-m-v2.0.0.tar.gz
$ mkdir vtkm-build
$ cd vtkm-build
$ cmake-gui ../vtk-m-v2.0.0
$ cmake --build -j .              # Runs make (or other build program)

A more detailed description of building VTK-m is available in the VTK-m Users Guide.


The VTK-m source distribution includes a number of examples. The goal of the VTK-m examples is to illustrate specific VTK-m concepts in a consistent and simple format. However, these examples only cover a small portion of the capabilities of VTK-m.

Below is a simple example of using VTK-m to create a simple data set and use VTK-m's rendering engine to render an image and write that image to a file. It then computes an isosurface on the input data set and renders this output data set in a separate image file:

#include <vtkm/cont/Initialize.h>
#include <vtkm/source/Tangle.h>

#include <vtkm/rendering/Actor.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/MapperRayTracer.h>
#include <vtkm/rendering/MapperVolume.h>
#include <vtkm/rendering/MapperWireframer.h>
#include <vtkm/rendering/Scene.h>
#include <vtkm/rendering/View3D.h>

#include <vtkm/filter/contour/Contour.h>

using vtkm::rendering::CanvasRayTracer;
using vtkm::rendering::MapperRayTracer;
using vtkm::rendering::MapperVolume;
using vtkm::rendering::MapperWireframer;

int main(int argc, char* argv[])
  vtkm::cont::Initialize(argc, argv, vtkm::cont::InitializeOptions::Strict);

  auto tangle = vtkm::source::Tangle(vtkm::Id3{ 50, 50, 50 });
  vtkm::cont::DataSet tangleData = tangle.Execute();
  std::string fieldName = "tangle";

  // Set up a camera for rendering the input data
  vtkm::rendering::Camera camera;
  camera.SetLookAt(vtkm::Vec3f_32(0.5, 0.5, 0.5));
  camera.SetViewUp(vtkm::make_Vec(0.f, 1.f, 0.f));
  camera.SetClippingRange(1.f, 10.f);
  camera.SetPosition(vtkm::Vec3f_32(1.5, 1.5, 1.5));
  vtkm::cont::ColorTable colorTable("inferno");

  // Background color:
  vtkm::rendering::Color bg(0.2f, 0.2f, 0.2f, 1.0f);
  vtkm::rendering::Actor actor(tangleData.GetCellSet(),
  vtkm::rendering::Scene scene;
  // 2048x2048 pixels in the canvas:
  CanvasRayTracer canvas(2048, 2048);
  // Create a view and use it to render the input data using OS Mesa

  vtkm::rendering::View3D view(scene, MapperVolume(), canvas, camera, bg);

  // Compute an isosurface:
  vtkm::filter::contour::Contour filter;
  // [min, max] of the tangle field is [-0.887, 24.46]:
  vtkm::cont::DataSet isoData = filter.Execute(tangleData);
  // Render a separate image with the output isosurface
  vtkm::rendering::Actor isoActor(
    isoData.GetCellSet(), isoData.GetCoordinateSystem(), isoData.GetField(fieldName), colorTable);
  // By default, the actor will automatically scale the scalar range of the color table to match
  // that of the data. However, we are coloring by the scalar that we just extracted a contour
  // from, so we want the scalar range to match that of the previous image.
  vtkm::rendering::Scene isoScene;

  // Wireframe surface:
  vtkm::rendering::View3D isoView(isoScene, MapperWireframer(), canvas, camera, bg);

  // Smooth surface:
  vtkm::rendering::View3D solidView(isoScene, MapperRayTracer(), canvas, camera, bg);

  return 0;

A minimal CMakeLists.txt such as the following one can be used to build this example.

cmake_minimum_required(VERSION 3.12...3.15 FATAL_ERROR)
project(VTKmDemo CXX)

#Find the VTK-m package
find_package(VTKm REQUIRED QUIET)

if(TARGET vtkm::rendering)
  add_executable(Demo Demo.cxx)
  target_link_libraries(Demo PRIVATE vtkm::filter vtkm::rendering vtkm::source)


VTK-m is distributed under the OSI-approved BSD 3-clause License. See LICENSE.txt for details.