zizmor: The Rust Compiler for GitHub Actions Security

A deep look at the tool that parses workflows, shells, and expressions like code, then turns CI security into a fast, offline, compiler-like analysis pass.

8 min read • View on GitHub • More from zizmorcore

A workflow document feeds into a machine with three inspection chambers, one for workflow structure, one for expressions, and one for embedded shell. A cracked thread of untrusted input tries to enter a run step, but a mechanical arm intercepts it before it reaches the output side. The image explains that zizmor analyzes GitHub Actions as layered code, not as flat YAML.
GitHub Actions is not just config here. It is a language stack with parseable layers, and zizmor treats it that way.
Key Takeaways

GitHub Actions looks like YAML, but that is a trap. The file can embed expressions, shell, secrets, permissions, and supply-chain decisions in a single workflow graph. zizmor treats that surface like a language runtime, which is why it feels closer to a compiler pass than a linter.

Why GitHub Actions Became a Security Language Problem

A workflow is not a static declaration. It expands event data, interpolates expressions, and executes shell with real side effects. That means a bad assumption in one step can become code execution, credential exposure, or an over-privileged action in the next.

That is the niche zizmor targets. It is built for the uncomfortable truth that CI config is executable logic, and that logic can be attacked through template injection, unsafe quoting, and overly broad permissions.

On a very basic level, I don’t really want zizmor to exist: what I really want is a CI/CD system that’s secure by construction, and that doesn’t require static analysis to be bolted onto it for a degree of safety.

William Woodruff, Creator/Maintainer · One year of zizmor

What zizmor Actually Analyzes

The repository is split like a real analysis stack. The main CLI lives in crates/zizmor, while supporting crates model GitHub Actions workflows, parse the ${{ ... }} expression language, navigate YAML paths, apply patches, and inspect shell blocks with Tree-sitter.

The key idea is not that zizmor sees strings. It sees transformations, then decides whether the transformed value becomes dangerous in context.

That matters because the engine does not stop at syntax. It uses typed GitHub Actions models, a dedicated expressions parser, and shell parsing to understand where untrusted data can flow, and where it becomes a sink. In security tooling, that is the difference between a warning and a diagnosis.

The registry makes findings feel like diagnostics

The audit registry collects checks into a central engine, then emits findings with locations, severity, and optional fixes. The important part is that a finding is not just a string. It carries YAML paths, line-aware context, and patch data that can rewrite the workflow.

That is compiler thinking. A parser feeds an analyzer. The analyzer produces structured diagnostics. Some diagnostics can even become edits.

A close-up cross-section of a workflow run step shows an untrusted token moving through an expression evaluator into a shell parser. On one path the token is blocked by a safety gate, on another it passes through as quoted and inert. The image explains that context determines whether data becomes a vulnerability.
The dangerous part is not the token itself. It is the place where a token crosses from data into executable context.

The Most Interesting Thing: Template Injection as Data Flow

This is the project’s real intellectual move. Many tools scan for suspicious strings, then stop. zizmor asks a harder question: where did the data come from, how was it transformed, and did it cross into a dangerous sink?

That is why the project leans on GitHub-specific knowledge. A value that is harmless in one context can become dangerous in run:, or when passed to an action input that controls behavior. The analysis is not generic taint tracking pasted onto YAML. It is CI-specific program analysis.

The result is a sharper definition of risk. A workflow event field is not bad by default. It becomes dangerous when expansion and execution line up in the wrong order, with the wrong quoting, inside the wrong step.

Why Personas Matter More Than Raw Severity

zizmor does not treat every user the same. Its persona system changes how much noise you are willing to tolerate. Regular mode aims for practical defaults, pedantic mode surfaces more edge cases, and auditor mode is for the people who want the full blast radius.

PersonaSignal levelBest for
RegularFocusedMost developers running checks in CI
PedanticHighSecurity-minded maintainers reviewing workflows
AuditorMaximumDeep review and triage sessions

That is a smart product decision. Most security tools fail not because they are wrong, but because they are noisy. Persona-based filtering turns the same analysis engine into different products for different jobs.

People like to use zizmor, even though it’s a security tool! Crazy!

William Woodruff, Creator/Maintainer · One year of zizmor

Rust Is Not Just a Language Choice Here

Rust gives zizmor speed, but speed alone is not the point. The workspace structure keeps the parser, models, patching logic, and audits separate, which makes the codebase easier to reason about and safer to extend.

The project also behaves like a serious compiler toolchain. It uses snapshot testing, strong linting, and explicit models instead of loose maps wherever possible. That engineering style matters because static analysis tools fail when their own internal abstractions are brittle.

ToolPrimary focusGitHub Actions depthSecurity specializationRuntimeBest for
zizmorSecurity analysisDeepHighRustCI security and template injection
actionlintCorrectness and lintingBroadMediumGoWorkflow syntax and best practices
CheckovIaC scanningShallow to mediumBroadPythonMulti-cloud policy checks
KICSIaC scanningShallow to mediumBroadGoGeneral configuration security

Offline-first behavior is part of the appeal. If a tool can run quickly without waiting on the network, it fits naturally into pre-commit hooks, local triage, and CI pipelines. That lowers friction, and friction is what kills adoption.

Who Built It, and Why It Caught On

William Woodruff built zizmor as a practical answer to a real gap: GitHub Actions needed security analysis that understood the language, not just the file format. The project’s traction came from a rare combination of depth and usability.

It is specialized enough to catch the bugs that matter, but fast enough to use daily. That combination is why teams can live with it, which is usually the hardest part of security tooling.

The larger lesson is simple. The best security tools do not just detect problems. They reshape how a team thinks about the system. zizmor does that by turning workflow review into a language-aware analysis pass instead of a manual audit ritual.