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.
Quick Start
To install ViennaPS for Python, simply run:
pip install ViennaPS
To 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.
Citation
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).
Releases
[!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.
Building
Supported Operating Systems
-
Linux (g++ / clang)
-
macOS (clang)
-
Windows (MSVC)
System Requirements
- 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:
External 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.
Installing
[!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.
Building the Python package locally
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.py
A 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.
Using the Python package
The ViennaPS Python package can be used by importing it in your Python scripts:
import viennaps as vps
By default, ViennaPS operates in two dimensions. You can set the dimension using:
vps.setDimension(2) # For 2D simulations
vps.setDimension(3) # For 3D simulations
For more details and examples, refer to the official documentation.
Integration in CMake projects
We recommend using CPM.cmake to consume this library.
-
Installation with CPM
CPMAddPackage("gh:viennatools/[email protected]")
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.
Shared Library
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=ON
If ViennaPS was built with shared libraries and you use ViennaPS in your project (see above), CMake will automatically link them to your project.
GPU Acceleration
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.
Basic Examples
See the examples README for build and run instructions, detailed descriptions, and images.
Publications Using ViennaPS
The following publications use ViennaPS for semiconductor process simulation:
Tests
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 build
Contributing
If 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 format
Authors
Contact us via: [email protected]
ViennaPS was developed under the aegis of the ‘Institute for Microelectronics’ at the ‘TU Wien’.
http://www.iue.tuwien.ac.at/
License
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.
评论