ViennaPS is a header-only C++ library for process and topography simulation in microelectronic fabrication. It models the evolution of 2D and 3D surfaces during etching, deposition, oxidation, and related steps, combining advanced level-set methods for surface evolution with Monte Carlo ray tracing for flux calculation and physics-based solvers for coupled processes. The oxidation model couples oxidant diffusion and viscous flow with nitride mask deformation.
ViennaPS supports both physics-based process models and fast emulation approaches, enabling flexible and efficient development of semiconductor processes. It can be easily integrated into existing C++ projects and also provides Python bindings for use in Python-based workflows. The library is actively developed and continuously improved to address the needs of process and topography simulation in microelectronics.
To install ViennaPS for Python, simply run:
pip install ViennaPSTo use ViennaPS in C++ follow the CMake instructions below. A ready-to-use CMake template is also available for a quick start: ViennaPS CMake Template.
For full documentation, visit ViennaPS Documentation.
If you use ViennaPS, please cite the following paper:
T. Reiter and L. Filipovic, ViennaPS: A flexible framework for semiconductor process simulation, SoftwareX, 32, 102453 (2025).
Note
ViennaPS is under active development. If you do have suggestions or find bugs, please let us know!
Releases are tagged on the master branch and available in the releases section.
ViennaPS is also available on the Python Package Index (PyPI) for most platforms.
-
Linux (g++ / clang)
-
macOS (clang)
-
Windows (MSVC)
- C++20 Compiler with OpenMP support
ViennaPS is part of the ViennaTools ecosystem and depends on several lightweight, header-only ViennaTools libraries. During configuration, CMake will fetch them automatically as part of the ViennaPS build. No separate installation step is required for these dependencies:
The following external dependencies are required to build ViennaPS. On most systems, installing them via a package manager (e.g. apt, brew, or vcpkg) is the fastest option:
CMake automatically checks for these dependencies during configuration. If they are not found, they can be built from source as part of the build.
To prefer a specific local installation, point CMake to it via VIENNAPS_LOOKUP_DIRS (a semicolon-separated list of prefixes):
cmake -B build -DVIENNAPS_LOOKUP_DIRS="/path/to/vtk;/path/to/embree"Alternatively (or additionally), you can use CMAKE_PREFIX_PATH if that better matches your local setup.
Note
For more detailed installation instructions and troubleshooting tips, have a look at the ViennaPS documentation.
ViennaPS is a header-only library, so no formal installation is required. To use ViennaPS in your C++ project, refer to the Integration in CMake projects section below.
The Python package can be built and installed using the pip command:
git clone https://github.com/ViennaTools/ViennaPS.git
cd ViennaPS
pip install .To build the Python package with GPU support, use the install script in python/scripts folder. On Linux, e.g., run:
python3 -m venv .venv # create virtual environment (optional, but recommended)
source .venv/bin/activate # activate virtual environment
python python/scripts/install_ViennaPS.pyA CUDA toolkit and driver compatible with your GPU must be installed on your system to use the GPU functionality.
Some features of the ViennaPS Python module depend on the ViennaLS Python module. The ViennaLS is installed automatically as a dependency. Note: A locally built ViennaPS Python module is typically not compatible with the ViennaLS package from PyPI. For details and troubleshooting, see this guide.
The ViennaPS Python package can be used by importing it in your Python scripts:
import viennaps as vpsBy default, ViennaPS operates in two dimensions. You can set the dimension using:
vps.setDimension(2) # For 2D simulations
vps.setDimension(3) # For 3D simulationsFor more details and examples, refer to the official documentation.
We recommend using CPM.cmake to consume this library.
-
Installation with CPM
CPMAddPackage("gh:viennatools/viennaps@4.7.0") target_link_libraries(${PROJECT_NAME} PUBLIC ViennaTools::ViennaPS)
-
With a local installation
In case you have ViennaPS installed in a custom directory, make sure to properly specify the
CMAKE_PREFIX_PATH.list(APPEND CMAKE_PREFIX_PATH "/your/local/installation") find_package(ViennaPS) target_link_libraries(${PROJECT_NAME} PUBLIC ViennaTools::ViennaPS)
Note: If you installed ViennaPS to a custom location, GPU kernels can not be built, since the CMake configuration does not support this setup. If you need GPU support, please use CPM.cmake.
In order to save build time during development, dynamically linked shared libraries can be used if ViennaPS was built with them. This is done by precompiling the most common template specialisations. In order to use shared libraries, use
cmake -B build -DVIENNAPS_PRECOMPILE_HEADERS=ONIf ViennaPS was built with shared libraries and you use ViennaPS in your project (see above), CMake will automatically link them to your project.
ViennaPS supports GPU acceleration for the ray tracing part of the library (since v3.4.0) and for the diffusion solver in the physics-based oxidation model. Both GPU features are still experimental. Details on how to enable GPU functionality can be found in the documentation.
See the examples README for build and run instructions, detailed descriptions, and images.
| Example | Description | Preview |
|---|---|---|
| Trench Deposition | Particle deposition in a trench with varying sticking probabilities. |  |
| SF₆/O₂ Hole Etching | Plasma etching with ion bombardment and varying particle fluxes. |  |
| Bosch Process | Comparison of emulation and physical models for deep reactive ion etching. |  |
| Wet Etching | Crystallographic wet etching of a cantilever structure. |  |
| Selective Epitaxy | Crystallographic SiGe growth on a silicon substrate. |  |
| Redeposition During Selective Etching | Byproduct transport and oxide regrowth in a Si₃N₄/SiO₂ stack. |  |
| GDS Mask Import | GDS mask transformations and conversion to level sets. |  |
| Fin Oxidation | Thermal oxidation of a silicon fin with anisotropic growth. |  |
| LOCOS Oxidation | Local oxidation beneath a nitride mask with bird's beak formation. |  |
The following publications use ViennaPS for semiconductor process simulation:
- Physics-Based Multi-Scale Modeling of Angled Reactive Ion Etching. SISPAD (2025).
- Simulation of a Polymer-Free DRIE Process Using SF₆/O₂ Plasma Etching. SISPAD (2025).
- Equipment-Informed Machine Learning-Assisted Feature-Scale Plasma Etching Model. SISPAD (2024).
- Loading Effect during SiGe/Si Stack Selective Isotropic Etching for Gate-All-Around Transistors. ACS Applied Electronic Materials (2024).
- Effect of Mask Geometry Variation on Plasma Etching Profiles. Micromachines (2023).
- Modeling Oxide Regrowth During Selective Etching in Vertical 3D NAND Structures. SISPAD (2023).
- Impact of Plasma Induced Damage on the Fabrication of 3D NAND Flash Memory. Solid-State Electronics (2022).
ViennaPS uses CTest to run its tests. In order to check whether ViennaPS runs without issues on your system, you can run:
cmake -B build -DVIENNAPS_BUILD_TESTS=ON
cmake --build build
ctest -E "Benchmark|Performance" --test-dir buildIf you want to contribute to ViennaPS, make sure to follow the LLVM Coding guidelines.
Make sure to format all files before creating a pull request:
cmake -B build
cmake --build build --target formatContact us via: viennatools@iue.tuwien.ac.at
ViennaPS was developed under the aegis of the 'Institute for Microelectronics' at the 'TU Wien'. http://www.iue.tuwien.ac.at/
Versions < 4.3.0 were released under MIT License. Starting with version 4.3.0, the project is licensed under GPL-3.0 License. For more details, please refer to the LICENSE file in the base directory of the repository.
Some third-party libraries used by ViennaPS are under their own permissive licenses (BSD, Apache-2.0).
See THIRD_PARTY_LICENSES.md for details.