.gitignore Generator — Stack Your Templates, Deduped and Sectioned

Real-world use cases

• Bootstrap a fresh Next.js + macOS + VS Code repo in 10 seconds

  You just ran `npx create-next-app` on a Mac. Before the first commit you want a real .gitignore, not the framework default that forgets about `.DS_Store` and your editor folder. Click the "Node web app" quick stack — it preselects Node, React/Next.js, dotenv, macOS and VS Code — eyeball the preview (`.next/`, `node_modules/`, `.env.local`, `.DS_Store`, `.vscode/*` with the shared config files negated), hit Copy, paste into `.gitignore`, commit. The first push is clean instead of leaking your local editor state to every collaborator.

• Stop a Terraform state file from leaking AWS secrets

  A teammate is about to commit infra code. Terraform `*.tfstate` files embed plaintext secrets (DB passwords, access keys) and `*.tfvars` often hold credentials. Select the Terraform template — it ships the exact `*.tfstate`, `*.tfstate.*`, `*.tfvars`, `**/.terraform/*` and plan-file rules with an inline comment explaining the danger. Drop it into the repo's .gitignore before the first `terraform apply`, and pair it with our env-secret-scanner to catch anything that already slipped through.

• Build one .gitignore for an Android + iOS monorepo

  A cross-platform mobile repo holds an Android Studio project and an Xcode project side by side, both opened in JetBrains and Xcode, all on macOS. Hand-merging four templates is where duplicate `build/` and `*.iml` lines creep in. Click the "Mobile" quick stack (Android + Xcode + macOS + JetBrains), let the dedupe collapse the shared `build/` and `.idea/` lines into a single occurrence, and you get one coherent file with four labelled sections instead of a copy-paste collage.

• Add a global ignore for OS and editor cruft across all repos

  You're tired of `.DS_Store` and `.idea/` showing up in every project. Select just macOS, Windows, Linux, VS Code, JetBrains and Vim, copy the output into `~/.gitignore_global`, and run `git config --global core.excludesFile ~/.gitignore_global` once. Now every repo on your machine ignores this junk without polluting any project's checked-in .gitignore — and your per-project files stay focused on build output.

• Audit and trim a bloated inherited .gitignore

  You inherit a 200-line .gitignore that someone pasted from three different generators, with `node_modules/` listed twice and a Unity block in a Python repo. Rebuild it from scratch here: select only the technologies the project actually uses, read the deduped sectioned output, and replace the old file. The labelled `### Section ###` headers make the next reviewer's job trivial, and the dedupe guarantees no rule appears twice.

Common pitfalls

• Adding a folder to .gitignore does not untrack files Git is already following. If `node_modules/` was committed before you ignored it, you still need `git rm -r --cached node_modules/` once, then commit. The ignore rule only governs files Git hasn't started tracking.

• Ignoring a whole directory and then trying to re-include one file with `!dir/keep.txt` silently fails — Git never looks inside an ignored directory. Ignore the contents (`dir/*`) instead, then negate the file you want back.

• Committing `Cargo.lock` is correct for application crates but wrong for library crates (it should be ignored so downstream consumers resolve their own versions). The Rust section ships the line commented out for exactly this reason — uncomment it only if your crate is a library.

Privacy