Generate a .gitignore from 52 templates, with a panel showing exactly what git will do to a set of paths and which line decided each one, re-inclusions ordered so the order you pick the templates in cannot change the result, and any negation a parent directory blocks reported with its fix
Initializing in your browser…
Generate fake data that is the thing it is labelled: card numbers with a real Luhn check digit, IBANs that pass ISO 7064 MOD 97-10, UUID v4 and v7 per RFC 9562, reserved e-mail and IP ranges, a seed so the same data comes back, and JSON, NDJSON, CSV or SQL output
Generate passwords from the Web Crypto generator by rejection sampling, with the entropy stated exactly from the alphabet, the cost of every rule computed, and crack times against four named attacker models
Stack CSS box shadows with any colour notation, and never write a declaration the browser will drop: a layer that will not parse is left out and flagged rather than taking every other layer down with it
Pick your languages, frameworks, IDEs and operating systems and get a .gitignore, with a panel showing exactly what git will do to a set of paths and which line decided each one.
A .gitignore makes exactly one claim, that git will ignore certain paths and keep others, so this tool shows what git will actually do rather than handing over a file and hoping. Under the output is a panel of paths with the verdict for each and the line and pattern that decided it, which is what `git check-ignore -v` prints. Every one of those verdicts is checked against real git in the test suite: 240 of them across sixteen template sets, with no disagreements.
Two faults that panel found in the shipped templates, both measured against git on 2026-09-04. **The order the templates were picked in changed the file.** Ticking VS Code and then Node.js ignored `.vscode/tasks.json` and `.vscode/launch.json`; ticking Node.js and then VS Code kept them, because gitignore(5) says the LAST matching pattern decides and the second template's broad rule undid the first one's negation. Nothing on the page showed the order and the list was alphabetical, so two people ticking the same boxes got different files. Every re-inclusion now goes into one section at the end, which makes the result independent of the order. **And twenty-four language templates excluded the whole `.vscode/` directory**, which is worse than it looks: gitignore(5) says a file under an excluded directory cannot be re-included at all, so picking Go alongside VS Code silently killed all five of the VS Code template's negations. IDE and OS rules now live only in their own templates, which is how github/gitignore keeps them in its Global directory.
Three smaller ones, each caught by asking git rather than by reading the text. The Rails template had `/tmp/` followed by `!/tmp/.keep`, where the upstream file has `/tmp/*`; git reported `tmp/.keep` as ignored, and the page now reports any negation a parent exclusion makes impossible along with the one-character fix. The Java template's blanket `*.jar` swallowed `gradle/wrapper/gradle-wrapper.jar`, which every JVM project using a wrapper commits. And four templates carried `.env.*` with no `!.env.example` beside it, so picking Go on its own hid the file that documents which secrets a project needs.
The output is also smaller. Repeated rules are dropped, which is a no-op once the re-inclusions are last, and custom rules stay verbatim at the very end so a rule written by hand always has the final say. A path box takes any path and says what happens to it, including when a parent directory is the reason and no negation can help.
Generate a comprehensive .gitignore before your first commit so build artifacts and editor files never enter the repo.
Combine patterns for multiple languages and tools into a single .gitignore.
Compare your current .gitignore against the recommended patterns for your stack to catch missing entries.
Because a language template that excludes the whole .vscode/ directory silently kills the VS Code template's re-inclusions. gitignore(5) says a file under an excluded directory cannot be re-included, and git does not even look inside such a directory. Twenty-four templates here did that, so the rules moved out, which is also how github/gitignore keeps them in its Global directory.
It did, and it does not now. Every re-inclusion goes into one section at the end, so a later template's broad rule cannot undo an earlier one's negation. Custom rules stay after that, so anything you write by hand still has the final say.
Almost certainly because a parent directory is excluded. gitignore(5): it is not possible to re-include a file if a parent directory of that file is excluded. `tmp/` followed by `!tmp/.keep` does nothing, while `tmp/*` followed by `!tmp/.keep` works, and the two look identical. The page finds this in whatever you have selected and names the line that blocks it.
Browsers strip a leading dot from a download name for safety, and there is nothing a page can do about it. Rename it once it is in the repository, or use Copy and paste it into a file you create yourself.
No. git only consults it for files it is not already tracking. Run git rm --cached <file> to stop tracking one, then commit; the ignore rule takes effect from then on.
This runs as client-side JavaScript. Keys, tokens, payloads, and other inputs never leave your device.