# computationalflowphysics/iblgf-amr architecture

> Architecture diagram of the GitHub repository computationalflowphysics/iblgf-amr, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-04-01). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/computationalflowphysics/iblgf-amr
- Repository: https://github.com/computationalflowphysics/iblgf-amr

## Overview

1. **Repository purpose and top-level shape**  
   This is a C++17 scientific computing library/application for immersed-boundary incompressible flow on unbounded domains, built around lattice Green’s functions (LGF). The code is organized as a reusable library under `include/iblgf`, with a small amount of compiled implementation in `src`, plus many scenario-specific executables/tests under `tests` and benchmarking drivers under `bench`.

2. **Public library boundary vs. implementation**  
   The `include/iblgf` tree is the main public API surface. It contains the domain model, solvers, operators, I/O, interpolation, linear algebra wrappers, and simulation/setup abstractions. The `src` tree provides non-header implementations for shared kernels such as LGF lookup tables, convolution, GPU convolution, and math helpers.

3. **Core simulation abstractions**  
   The simulation flow is anchored by `simulation.hpp`, the `setup_*` headers, and problem-specific test drivers. A setup object configures geometry, physics, boundary conditions, and algorithm choice, then feeds the solver stack. This is the boundary where application-specific cases enter the library.

4. **Domain representation and adaptive mesh infrastructure**  
   `include/iblgf/domain` holds the main spatial/data model:  
   - `octree` for adaptive hierarchical mesh indexing and traversal,  
   - `dataFields` for blocks, nodes, views, and field storage,  
   - `decomposition` and `mpi` for distributed ownership and task exchange,  
   - `ib` / `ib_communicator` for immersed-boundary coupling.  
   This layer is the backbone for how state is partitioned, refined, communicated, and accessed across ranks.

5. **Parallel execution model**  
   MPI is the primary scaling boundary, with explicit client/server/task abstractions in `domain/mpi` and `domain/decomposition`. OpenMP variants appear in several solver headers, and CUDA is used for selected convolution/Poisson paths. The architecture therefore supports multiple parallel backends, but MPI distributed memory is the main coordination layer.

6. **LGF and elliptic operator machinery**  
   The `lgf`, `operators`, `interpolation`, and `utilities/convolution*` modules implement the numerical heart of the code: applying lattice Green’s function operators, interpolation between grids, and convolution-based solves. These pieces provide the fast unbounded-domain elliptic solve path used by Poisson and Helmholtz-related workflows.

7. **Solver stack and numerical workflows**  
   `include/iblgf/solver` contains several solver families:  
   - Poisson and Helmholtz solvers, including OpenMP variants,  
   - time-integration and implicit methods (`ifherk`, Helmholtz-FFT, linear and Helmholtz-coupled variants),  
   - Newton and stability solvers,  
   - modal analysis and matrix-free components,  
   - direct solver hooks such as MKL PARDISO and ScaLAPACK interfaces.  
   This layer consumes the domain/operator abstractions and produces the actual physical updates, eigen/spectral analyses, or linear-system solutions.

8. **Linear algebra and external numerical backends**  
   `linalg`, `tensor`, and solver-specific wrappers abstract numerical arrays and BLAS-like operations, mostly via xtensor/xtensor-blas. The repository also integrates with heavy external backends when needed: FFTW, MKL, ScaLAPACK, PETSc, and SLEPc. These are not just optional utilities; they define alternate solver paths and are exercised by dedicated tests.

9. **I/O, restart, and reproducibility**  
   The `IO` subsystem, especially `IO/chombo`, handles HDF5-based structured output and restart data. The README describes timestamped run directories, restart files, and resume support, indicating that long-running simulations are checkpointable and reproducible. This is an important architectural boundary between compute kernels and persistent run metadata/results.

10. **Case-specific test executables as integration examples**  
   The `tests` tree is effectively a catalog of end-to-end application drivers rather than unit tests alone. It includes Poisson, Helmholtz, Newton, immersed-boundary flow, stability, spectral, FFT/MPI, GPU, and PETSc/SLEPc cases. These tests show how the library is composed for different physics and backend combinations, and they are the clearest examples of the data flow from config files → setup → domain/communication → solver → HDF5 reference comparison.

11. **Benchmarking and experiment generation tooling**  
   The `bench` directory contains Python scripts and case generators for IF-HERK, vortex ring, Poisson GPU, and related performance studies. These scripts sit outside the core library and are used to mass-produce inputs, launch jobs, and analyze results, which makes them useful for performance/regression architecture but not part of the runtime solver path.

12. **Build, packaging, and CI environment**  
   The project is CMake-based and includes a `FindFFTW.cmake`, a package config template, GitHub Actions workflows for test/benchmark/containerization, and Docker helper scripts. This indicates a portable HPC-oriented build/deploy model: local CMake builds, CI validation, and containerized execution for reproducibility.

13. **What an architecture diagram should emphasize**  
   The main diagram should show: configuration/setup entering at the top, a distributed adaptive domain and data-field layer in the middle, solver/operator/LGF kernels as the compute core, MPI/OpenMP/CUDA as execution backends, and HDF5 restart/output at the bottom. Optional external solver backends (FFTW, MKL, PETSc/SLEPc, ScaLAPACK) should be shown as interchangeable integration points rather than primary subsystems.

Main entry points: [`tests/poisson/poisson.cpp`](https://github.com/computationalflowphysics/iblgf-amr/blob/main/tests/poisson/poisson.cpp) (Drivers), [`include/iblgf/domain/domain.hpp`](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/domain.hpp) (Domain), [`include/iblgf/operators/operators.hpp`](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/operators/operators.hpp) (Operators), [`include/iblgf/simulation.hpp`](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/simulation.hpp) (Simulation)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_g_api["Public API"]
  node_n_simulation["Simulation<br/>runtime entry<br/>[simulation.hpp]"]
  node_n_domain["Domain<br/>spatial model<br/>[domain.hpp]"]
end

subgraph group_g_domain["Domain + Parallelism"]
  node_n_octree{{"Octree<br/>adaptive mesh<br/>[tree.hpp]"}}
  node_n_datafields["Data fields<br/>field storage<br/>[datafield.hpp]"]
  node_n_decomp["Decomposition<br/>mpi ownership<br/>[decomposition.hpp]"]
  node_n_mpi["MPI layer<br/>communication<br/>[task_manager.hpp]"]
  node_n_ib["Immersed boundary<br/>coupling"]
end

subgraph group_g_core["Numerical Core"]
  node_n_lgf["LGF<br/>green's function<br/>[lgf.hpp]"]
  node_n_ops["Operators<br/>discrete ops<br/>[operators.hpp]"]
  node_n_intrp["Interpolation<br/>grid transfer<br/>[interpolation.hpp]"]
  node_n_conv["Convolution<br/>kernel compute<br/>[convolution.hpp]"]
  node_n_linalg["Linalg<br/>array algebra<br/>[linalg.hpp]"]
end

subgraph group_g_solver["Solvers"]
  node_n_poi["Poisson<br/>elliptic solver<br/>[poisson.hpp]"]
  node_n_helm["Helmholtz<br/>elliptic solver<br/>[HelmholtzFFT.hpp]"]
  node_n_ifherk["IF-HERK<br/>time integration<br/>[ifherk.hpp]"]
  node_n_newton["Newton<br/>nonlinear solve<br/>[NewtonMethod.hpp]"]
  node_n_stab["Stability<br/>spectral analysis"]
  node_n_direct["Direct solve<br/>backend wrapper"]
end

subgraph group_g_io["I/O"]
  node_n_io["I/O<br/>persistence"]
  node_n_chombo["Chombo HDF5<br/>restart io<br/>[chombo.hpp]"]
end

subgraph group_g_runtime["Runtime Setup"]
  node_n_setup_base["Setup base<br/>case config<br/>[setup_base.hpp]"]
  node_n_setups["Problem setups<br/>case configs"]
end

subgraph group_g_tests["Drivers"]
  node_n_tests["Drivers<br/>integration cases<br/>[poisson.cpp]"]
  node_n_bench["Benchmarks<br/>experiment tools<br/>[make_jobs.py]"]
end

subgraph group_g_tools["Build + Tooling"]
  node_n_build["Build system<br/>cmake<br/>[CMakeLists.txt]"]
  node_n_ci["CI + containers<br/>automation<br/>[test.yml]"]
end

node_n_simulation -->|"uses"| node_n_setup_base
node_n_setup_base -->|"specialized by"| node_n_setups
node_n_setups -->|"configure"| node_n_domain
node_n_domain -->|"contains"| node_n_octree
node_n_domain -->|"contains"| node_n_datafields
node_n_domain -->|"contains"| node_n_decomp
node_n_domain -->|"communicates via"| node_n_mpi
node_n_domain -->|"couples"| node_n_ib
node_n_domain -->|"drives"| node_n_ops
node_n_ops -->|"applies"| node_n_lgf
node_n_ops -->|"uses"| node_n_intrp
node_n_lgf -->|"implemented by"| node_n_conv
node_n_conv -->|"builds on"| node_n_linalg
node_n_poi -->|"consumes"| node_n_ops
node_n_helm -->|"consumes"| node_n_lgf
node_n_ifherk -->|"couples to"| node_n_helm
node_n_newton -->|"linearizes"| node_n_ops
node_n_stab -->|"analyzes"| node_n_linalg
node_n_direct -->|"wraps"| node_n_linalg
node_n_tests -->|"exercise"| node_n_simulation
node_n_tests -->|"covers"| node_n_poi
node_n_tests -->|"covers"| node_n_helm
node_n_tests -->|"covers"| node_n_ifherk
node_n_tests -->|"covers"| node_n_newton
node_n_tests -->|"covers"| node_n_stab
node_n_tests -->|"covers"| node_n_direct
node_n_tests -->|"compares"| node_n_chombo
node_n_io -->|"implements"| node_n_chombo
node_n_simulation -->|"writes"| node_n_io
node_n_bench -->|"extends"| node_n_tests
node_n_build -->|"builds"| node_n_tests
node_n_ci -->|"validates"| node_n_build

click node_n_simulation "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/simulation.hpp"
click node_n_setup_base "https://github.com/computationalflowphysics/iblgf-amr/blob/main/setups/setup_base.hpp"
click node_n_setups "https://github.com/computationalflowphysics/iblgf-amr/blob/main/setups/setup_helmholtz.hpp"
click node_n_domain "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/domain.hpp"
click node_n_octree "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/octree/tree.hpp"
click node_n_datafields "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/dataFields/datafield.hpp"
click node_n_decomp "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/decomposition/decomposition.hpp"
click node_n_mpi "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/mpi/task_manager.hpp"
click node_n_ib "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/ib_communicator.hpp"
click node_n_lgf "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/lgf/lgf.hpp"
click node_n_ops "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/operators/operators.hpp"
click node_n_intrp "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/interpolation/interpolation.hpp"
click node_n_conv "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/utilities/convolution.hpp"
click node_n_linalg "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/linalg/linalg.hpp"
click node_n_poi "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/poisson/poisson.hpp"
click node_n_helm "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/time_integration/HelmholtzFFT.hpp"
click node_n_ifherk "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/time_integration/ifherk.hpp"
click node_n_newton "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/Newton/NewtonMethod.hpp"
click node_n_stab "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/Stability_solver/Stability_solver.hpp"
click node_n_direct "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/DirectSolver/MKLPardiso_solve.hpp"
click node_n_io "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/IO/output_directory.hpp"
click node_n_chombo "https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/IO/chombo/chombo.hpp"
click node_n_tests "https://github.com/computationalflowphysics/iblgf-amr/blob/main/tests/poisson/poisson.cpp"
click node_n_bench "https://github.com/computationalflowphysics/iblgf-amr/blob/main/bench/poisson_gpu/make_jobs.py"
click node_n_build "https://github.com/computationalflowphysics/iblgf-amr/blob/main/CMakeLists.txt"
click node_n_ci "https://github.com/computationalflowphysics/iblgf-amr/blob/main/.github/workflows/test.yml"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_n_simulation,node_n_domain,node_n_tests,node_n_bench toneBlue
class node_n_octree,node_n_datafields,node_n_decomp,node_n_mpi,node_n_ib,node_n_build,node_n_ci toneAmber
class node_n_lgf,node_n_ops,node_n_intrp,node_n_conv,node_n_linalg toneMint
class node_n_poi,node_n_helm,node_n_ifherk,node_n_newton,node_n_stab,node_n_direct toneRose
class node_n_io,node_n_chombo toneIndigo
class node_n_setup_base,node_n_setups toneTeal
```

## Components

### Public API

Header-only library surface exposed from include/iblgf

- [Simulation](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/simulation.hpp): runtime entry · Top-level simulation orchestration and lifecycle · `include/iblgf/simulation.hpp`
- [Domain](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/domain.hpp): spatial model · Umbrella domain model for mesh, data, communication, and immersed boundary coupling · `include/iblgf/domain/domain.hpp`

### Domain + Parallelism

Adaptive mesh, distributed ownership, and communication layers

- [Octree](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/octree/tree.hpp): adaptive mesh · Hierarchical indexing and traversal for refined grids · `include/iblgf/domain/octree/tree.hpp`
- [Data fields](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/dataFields/datafield.hpp): field storage · Blocks, nodes, views, and field containers · `include/iblgf/domain/dataFields/datafield.hpp`
- [Decomposition](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/decomposition/decomposition.hpp): mpi ownership · Distributed partitioning and client/server task exchange · `include/iblgf/domain/decomposition/decomposition.hpp`
- [MPI layer](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/mpi/task_manager.hpp): communication · Task, halo, and registry helpers for distributed execution · `include/iblgf/domain/mpi/task_manager.hpp`
- [Immersed boundary](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/domain/ib_communicator.hpp): coupling · IBM coupling and boundary communication · `include/iblgf/domain/ib_communicator.hpp`

### Numerical Core

LGF operators, interpolation, convolutions, and linear algebra wrappers

- [LGF](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/lgf/lgf.hpp): green's function · Lattice Green's function and Helmholtz lookup tables · `include/iblgf/lgf/lgf.hpp`
- [Operators](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/operators/operators.hpp): discrete ops · Operator assembly and application interfaces · `include/iblgf/operators/operators.hpp`
- [Interpolation](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/interpolation/interpolation.hpp): grid transfer · Interpolation between adaptive and cell-centered representations · `include/iblgf/interpolation/interpolation.hpp`
- [Convolution](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/utilities/convolution.hpp): kernel compute · CPU and GPU convolution kernels used by LGF-based solves · `include/iblgf/utilities/convolution.hpp`
- [Linalg](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/linalg/linalg.hpp): array algebra · Vector and tensor abstractions over xtensor-style backends · `include/iblgf/linalg/linalg.hpp`

### Solvers

Poisson, Helmholtz, time-integration, Newton, stability, and spectral workflows

- [Poisson](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/poisson/poisson.hpp): elliptic solver · Poisson solver family including OpenMP variants · `include/iblgf/solver/poisson/poisson.hpp`
- [Helmholtz](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/time_integration/HelmholtzFFT.hpp): elliptic solver · Helmholtz solver family and FFT-based time-integration path · `include/iblgf/solver/time_integration/HelmholtzFFT.hpp`
- [IF-HERK](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/time_integration/ifherk.hpp): time integration · Implicit-explicit time integration and Helmholtz-coupled variants · `include/iblgf/solver/time_integration/ifherk.hpp`
- [Newton](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/Newton/NewtonMethod.hpp): nonlinear solve · Newton and Jacobian-based nonlinear solution workflows · `include/iblgf/solver/Newton/NewtonMethod.hpp`
- [Stability](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/Stability_solver/Stability_solver.hpp): spectral analysis · Stability and modal analysis routines · `include/iblgf/solver/Stability_solver/Stability_solver.hpp`
- [Direct solve](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/solver/DirectSolver/MKLPardiso_solve.hpp): backend wrapper · MKL PARDISO and ScaLAPACK direct solver hooks · `include/iblgf/solver/DirectSolver/MKLPardiso_solve.hpp`

### I/O

Output, checkpointing, and restart persistence

- [I/O](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/IO/output_directory.hpp): persistence · Run output, parallel streams, and checkpoint/restart support · `include/iblgf/IO/output_directory.hpp`
- [Chombo HDF5](https://github.com/computationalflowphysics/iblgf-amr/blob/main/include/iblgf/IO/chombo/chombo.hpp): restart io · Structured HDF5 output and restart serialization · `include/iblgf/IO/chombo/chombo.hpp`

### Runtime Setup

Simulation configuration and problem-specific entry points

- [Setup base](https://github.com/computationalflowphysics/iblgf-amr/blob/main/setups/setup_base.hpp): case config · Common simulation setup interface · `setups/setup_base.hpp`
- [Problem setups](https://github.com/computationalflowphysics/iblgf-amr/blob/main/setups/setup_helmholtz.hpp): case configs · Helmholtz, Newton, linear, and stability setup specializations · `setups/setup_helmholtz.hpp`

### Drivers

Integration-style executables and backend-specific cases

- [Drivers](https://github.com/computationalflowphysics/iblgf-amr/blob/main/tests/poisson/poisson.cpp): integration cases · Representative end-to-end executables and backend exercises · `tests/poisson/poisson.cpp`
- [Benchmarks](https://github.com/computationalflowphysics/iblgf-amr/blob/main/bench/poisson_gpu/make_jobs.py): experiment tools · Case generators, plotting, and performance study scripts · `bench/poisson_gpu/make_jobs.py`

### Build + Tooling

Build system, CI, containerization, and benchmark tooling

- [Build system](https://github.com/computationalflowphysics/iblgf-amr/blob/main/CMakeLists.txt): cmake · CMake project configuration and package discovery · `CMakeLists.txt`
- [CI + containers](https://github.com/computationalflowphysics/iblgf-amr/blob/main/.github/workflows/test.yml): automation · GitHub Actions workflows and Docker helpers · `.github/workflows/test.yml`

## Connections

- Simulation → Setup base: uses · Simulation lifecycle is configured through a setup abstraction
- Setup base → Problem setups: specialized by · Concrete problem setups provide case-specific parameters and physics
- Problem setups → Domain: configure · Setups create and initialize the domain model
- Domain → Octree: contains · Adaptive spatial indexing is a core part of the domain
- Domain → Data fields: contains · Field storage and views live under the domain model
- Domain → Decomposition: contains · Distributed ownership and task decomposition are domain concerns
- Domain → MPI layer: communicates via · MPI task and halo plumbing coordinate distributed execution
- Domain → Immersed boundary: couples · Immersed-boundary coupling bridges geometry and solver state
- Domain → Operators: drives · Domain state feeds discrete operators
- Operators → LGF: applies · Operators are built on lattice Green's function kernels
- Operators → Interpolation: uses · Operators rely on interpolation between representations
- LGF → Convolution: implemented by · LGF application depends on convolution kernels
- Convolution → Linalg: builds on · Convolution and solver kernels use linear algebra abstractions
- Poisson → Operators: consumes · Poisson solves use the operator layer
- Helmholtz → LGF: consumes · Helmholtz paths use LGF kernels and lookup tables
- IF-HERK → Helmholtz: couples to · IF-HERK variants embed Helmholtz solves inside time stepping
- Newton → Operators: linearizes · Newton workflows assemble matrix-free or explicit Jacobian operators
- Stability → Linalg: analyzes · Stability and modal analysis rely on linear algebra backends
- Direct solve → Linalg: wraps · Direct solver interfaces sit behind the linear algebra layer
- Drivers → Simulation: exercise · Integration drivers instantiate the full simulation stack
- Drivers → Poisson: covers · Dedicated cases validate Poisson workflows
- Drivers → Helmholtz: covers · Dedicated cases validate Helmholtz workflows
- Drivers → IF-HERK: covers · Dedicated cases validate time-integration workflows
- Drivers → Newton: covers · Dedicated cases validate Newton workflows
- Drivers → Stability: covers · Dedicated cases validate stability and spectral workflows
- Drivers → Direct solve: covers · Dedicated cases exercise MKL and ScaLAPACK paths
- Drivers → Chombo HDF5: compares · Cases use HDF5 reference data and restart/output checks
- I/O → Chombo HDF5: implements · Chombo HDF5 is the primary persistence backend
- Simulation → I/O: writes · Simulation results and checkpoints flow to I/O
- Benchmarks → Drivers: extends · Benchmark scripts generate or wrap case definitions
- Build system → Drivers: builds · CMake orchestrates the executable catalog
- CI + containers → Build system: validates · Workflows run builds, tests, and containerized checks
