GitHub rust-2026-template — my Rust starter in 2026

I got tired of setting up the same things every new Rust project. Clippy config, CI pipelines, linker flags, pre-commit hooks, cargo-nextest... all from scratch, every time. And then doing it again every time I switched AI coding tools — re-explaining the project structure, the lint rules, what's off-limits.

So I built rust-2026-template. Click "Use this template", point your agent at it, and you're coding — not configuring.

Version 2 is out now with a significant number of additions. Here's what's in it.

The setup I always end up with anyway

Rust 2024 edition, MSRV 1.87 pinned via rust-toolchain.toml. Workspace layout from day one — even for small projects. Refactoring a single-crate project into a workspace later is just pain you don't need:

crates/
  example-crate/
  sample-app/

Rename those, done.

One script, full quality gate

./scripts/quality-gates.sh

This runs fmt, clippy (pedantic, zero warnings), cargo nextest, cargo audit, cargo deny, and optionally cargo mutants. Same thing CI runs. I run it before every commit so there are no surprises.

Mutation testing with cargo-mutants is the one I'd push people to try — it tells you whether your tests actually catch bugs or just touch code. Very different things.

Security defaults, not an afterthought

• deny.toml — license policy and banned crates
• .gitleaks.toml — secret scanning before anything gets committed
• .pre-commit-config.yaml — hooks run locally, not just in CI
• .shellcheckrc — shell script quality gate (new in v2)

The goal is that you never have to remember to do this. It just happens.

AI agents work out of the box

This is the part I use the most now. Every AI coding tool needs project context — and they all want it in a slightly different place. Instead of re-explaining conventions every session, it's all checked in:

.agents/        — skill definitions per agent
.claude/        — Claude Code config
.cursor/        — Cursor rules
.gemini/        — Gemini CLI config
.jules/         — Jules config (new in v2)
.opencode/      — OpenCode config
.qwen/          — Qwen CLI config
.windsurf/      — Windsurf config
AGENTS.md       — canonical project rules, read by every agent
llms.txt        — machine-readable project overview
llms-full.txt   — complete source context for deep analysis (new in v2)

AGENTS.md is the key file. It tells any agent: the workspace layout, the lint rules, commit conventions, and what to never touch. You switch from Claude Code to Codex to OpenCode mid-project — they all read the same rules. No re-onboarding.

The new llms-full.txt is auto-generated and contains the full source context for agents that need deep analysis. Regenerate both after significant architectural changes:

bash scripts/generate-llms-txt.sh

When you start a new project from this template, you can also just hand the repo URL directly to your agent as context:

"Use github.com/d-oit/rust-2026-template as the reference for this project."

It'll pick up the structure, the tooling choices, and the conventions without you writing a single prompt about them.

Performance defaults you forget to add

.cargo/config.toml sets the mold linker. One line, noticeably faster incremental builds. The dev profile is tuned to avoid the "my debug build takes forever" problem. Small thing, but after six months on a project you'll notice it.

Nix users get flake.nix with clang and mold in the devShell, plus .envrc for direnv/nix-direnv integration.

New in v2: Benchmarks

The template now includes a two-layer benchmark structure:

• benches/ — standard Criterion harnesses at the crate root
• benchmarks/ — a separate workspace crate for complex, cross-crate benchmark suites

cargo bench -p benchmarks

The CI pipeline also compile-checks benchmarks on every PR so they never silently break.

New in v2: Fuzz Testing

A fuzz testing scaffold is included using cargo-fuzz:

# Install cargo-fuzz (nightly required)
cargo install cargo-fuzz

# Run fuzz targets
cargo fuzz run fuzz_parse_input -- -max_total_time=30

The fuzzer runs weekly via GitHub Actions (.github/workflows/fuzz.yml).

New in v2: Feature Flags

The template demonstrates composable feature flags for pluggable backends:

New in v2: VERSION file

A VERSION file at the repo root is the plain-text single source of truth for tooling that can't easily parse TOML. The CI pipeline verifies VERSION matches Cargo.toml on every push to main — no more version drift between files.

New in v2: Release engineering

• dist-workspace.toml + release.toml for cargo-dist automated releases
• cliff.toml for git-cliff changelog generation
• CHANGELOG-TEMPLATE.md for tracking template-level changes separately from your project changes
• MIGRATION.md for upgrade guidance

New in v2: Code quality integrations

• Codecov (.codecov.yml) — coverage gate enforcement
• Codacy (.codacy.yml) — additional static analysis
• commitlint (commitlint.config.cjs) — enforces conventional commit format, hardened against bot-authored failures

Use it

1. Hit "Use this template" on GitHub — or tell your agent: use github.com/d-oit/rust-2026-template as the reference for this project
2. Follow QUICKSTART.md — rename the crates, update Cargo.toml
3. Run ./scripts/quality-gates.sh once locally

MIT licensed. PRs welcome — if there's a pattern you always add to Rust projects, open an issue.

→ github.com/d-oit/rust-2026-template