Tutorial: Spack 101

This is an introduction to Spack with lectures and live demos. It was last presented at the ISC High Performance 2026 Conference Conference on June 22, 2026. The event was a half day in-person tutorial.

You can use these materials to teach a course on Spack at your own site, or you can just skip ahead and read the live demo scripts to see how Spack is used in practice.

Slides

Download Slides.

Full citation: Gregory Becker, Harmen Stoppels, Massimiliano Culpo, Alec Scott, Kathleen Shea, Adam Stewart, Michael Kuhn, and Todd Gamblin. Managing HPC Software Complexity with Spack. ISC-HPC 2026 (ISC26). Hamburg, Germany, June 22-25, 2026.

Video

For the last recorded video of this tutorial, see the HPCIC Tutorial 2025 version.

Live Demos

We provide scripts that take you step-by-step through basic Spack tasks. They correspond to sections in the slides above.

To run through the scripts, we provide the spack/tutorial container image. You can invoke

$ docker pull ghcr.io/spack/tutorial:isc26
$ docker run -it ghcr.io/spack/tutorial:isc26

to start using the container. You should now be ready to run through our demo scripts:

1. Basic Installation Tutorial

2. Environments Tutorial

3. Package Creation Tutorial

4. Stacks Tutorial

5. Developer Workflows Tutorial

6. Binary Caches Tutorial

Other sections from past tutorials are also available, although they may not be kept up-to-date as frequently:

1. Configuration Tutorial

2. Module Files Tutorial

3. Spack Package Build Systems

4. Advanced Topics in Packaging

5. Scripting with Spack

Full contents:

Links

• Main Spack Documentation

Tutorial

• Basic Installation Tutorial
  • Setting Up Spack
  • Installing Packages
  • The Spec Syntax
    • Versions
    • Variants
    • Direct Dependencies
    • Transitive Dependencies
    • Virtual Dependencies
    • Spec Syntax Reference
  • Querying Installations
  • Trilinos: A More Complex Example
  • Uninstalling Packages
  • Customizing Compilers
  • Next Steps
• Environments Tutorial
  • Working with Environments
    • Creating and Activating Environments
    • Installing Packages
    • Using installed packages
    • Removing Packages
  • Environments on disk
  • Configuring environments
  • Sharing environments
    • Using spack.yaml
    • Using spack.lock
  • Removing environments
  • More information
    • Setting up and building environments
    • Using environments
    • Finding examples of environments
• Package Creation Tutorial
  • What is a Spack Package?
  • Getting Started
  • Creating the Package File
  • Adding Package Documentation
  • Adding Dependencies
  • Debugging Package Builds
    • Reviewing the Build Log
    • Building Manually
  • Specifying Configure Arguments
  • Adding Variants
  • Querying the Spec Object
    • Querying Spec Versions
    • Querying Spec Names
    • Querying Variants
  • Multiple Build Systems
  • Cleaning Up
  • More information
    • Customizing package-related environments
    • Testing an installation
    • Using other build systems
    • Making a package externally detectable
• Stacks Tutorial
  • Installing a Software Stack
    • Spec groups
    • Tuning concretizer options
    • Spec matrices
    • Reusable definitions
    • Conditional definitions
    • Other useful features
  • Multiple Filesystem Views
  • Module Files
  • Summary
• Developer Workflows Tutorial
  • Installing from local source
  • Development iteration cycles
    • Multi-package development
    • Pre-configuring development environments
    • Sharing development environments
  • Workflow Summary
  • Optional: Tips and Tricks
    • Source Code Management
    • Navigation and the Build Environment
    • Combinatorics
• Binary Caches Tutorial
  • Installing julia from the build cache
  • Setting up a local OCI build cache
  • Pushing to the OCI build cache
  • Reinstalling from the OCI build cache
  • Creating runnable container images
  • Spack environments as container images
  • Relation to docker build workflows
  • Relocation
  • Using build caches in CI
  • Summary

Additional sections

• Configuration Tutorial
  • Configuration from the command line
  • Configuration Scopes
  • YAML Format
  • Compiler Configuration
    • Compiler flags
    • Advanced compiler configuration
  • Configuring Package Preferences
    • Variant preferences
    • External packages
    • Installation permissions
  • High-level Config
  • Conclusion
• Module Files Tutorial
  • Setup for the Tutorial
    • Build a module tool
    • Add a new compiler
    • Build the software that will be used in the tutorial
  • What are Module Files?
    • Module Systems
    • How does Spack generate module files?
    • Modules vs spack load
  • Non-hierarchical Module Files
    • Filter unwanted modifications to the environment
    • Prevent some module files from being generated
    • Change module file naming
    • Add custom environment modifications
    • Autoload dependencies
  • Hierarchical Module Files
    • Core/Compiler/MPI
    • Add LAPACK to the hierarchy
  • Working with Templates
    • Module file templates
    • Extend the default templates
    • Restore settings for future sections
• Spack Package Build Systems
  • Package Class Hierarchy
  • Package
  • Autotools
  • Makefile
  • CMake
  • PythonPackage
  • Other Build Systems
• Advanced Topics in Packaging
  • Setup for the Tutorial
  • Modifying a Package’s Build Environment
    • Set environment variables in dependent packages at build-time
    • Set environment variables in your own package
  • Retrieving Library Information
    • Accessing dependency libraries
    • Providing libraries to dependents
  • Other Packaging Topics
    • Attach attributes to other packages
    • Extra query parameters
• Scripting with Spack
  • Scripting with spack find
    • spack find --format
    • spack find --json
  • Introducing the spack python command
    • Accessing the Spec object
    • Querying the Spack database
    • Using scripts
  • Using the spack-python executable