Which templates should I combine?

Start with your language runtime (Node, Python, Go, or Rust), add your framework if one applies (React, Next.js, Django), then add your editor (VS Code or JetBrains) and your OS (macOS or Windows). A typical web project uses four to five templates stacked together.

What does merged and deduplicated mean?

Templates overlap - Node, React, and Next.js all ignore node_modules, for example. The generator merges your selection into one file and removes duplicate rules, so you get a clean .gitignore without the repeated blocks that stacking raw templates would produce.

Do the templates cover secrets and env files?

Yes, the runtime templates include .env patterns and common credential paths. But no generator can know the specific secrets of your project - always review the output before your first commit, and never rely on .gitignore alone as your only safeguard.

Does .gitignore untrack files already committed?

No. Ignore rules only affect untracked files — anything git already tracks stays tracked. To stop tracking a previously committed file, run git rm --cached path/to/file (which keeps it on disk), commit the removal, and the ignore rule takes effect from then on.

Where should the .gitignore file live?

At the repository root for project-wide rules. Git also reads .gitignore files in subdirectories for folder-specific rules, and ~/.config/git/ignore (or ~/.gitignore_global) for personal rules like editor leftovers that should never enter any repo. This generator writes the root file — the one you commit and share.

🙈

.gitignore Generator

Compose a .gitignore from curated per-stack templates — deduped and ready to commit.

100% LOCAL12 stack templatesMerge & dedupeCopy or download100% local

Saved Configurations· Auto-save on

▾

La calculatricePage 1

Stacks & platforms

3 templates · 16 rule lines

# .gitignore — generated with FreeToolHub

node_modules/
npm-debug.log*
yarn-error.log*
.env
.env.local
coverage/
dist/
build/

.DS_Store
.AppleDouble
.LSOverride
._*

.vscode/*
!.vscode/settings.json
!.vscode/extensions.json
history/

Data Source & Legal Disclaimer

Effective: 2026Last updated: 2026-09-07Update: Manual review

Sources: GitHub gitignore templates

The .gitignore is generated locally from templates. Nothing is uploaded.

See all data sources & update policy →

Comment ça marchePage 2

↩ Retour à la calculatrice

How .gitignore patterns work — illustrated

Git matches patterns top-to-bottom: later rules can re-include earlier exclusions — that is why the VS Code template excludes .vscode/* then re-includes !.vscode/settings.json. A trailing slash (build/) restricts matches to directories; * globs within a path segment, and patterns with a slash are anchored to the repository root. Combining templates is safe because this generator dedupes identical lines across stacks — picking Node + macOS + VS Code yields one clean file, not three copies of the same rules.

Pick stacks → union of blocks (deduped) → one .gitignore

Template blocks overlap heavily; the builder keeps the first occurrence of each unique line.

A new monorepo — Dev's first commit hygiene

Dev starts a TypeScript monorepo on a Mac with teammates on Windows, all using VS Code, deploying to Cloudflare.

Pick the stacks:He checks Node, macOS, Windows, VS Code, and Cloudflare — five templates, one click each
Review the union:The output merges all five: node_modules/, .DS_Store/, Thumbs.db, .vscode/* with its two re-includes, and .wrangler/ — duplicates like node_modules/ appear once because the builder dedupes
Commit before the first push:He downloads the file into the repo root before committing anything, so node_modules never enters history
Later additions:When a Python service joins the monorepo, he regenerates with the Python template checked — existing rules stay stable, new ones append

↩ Back to generator

FAQ et détailsPage 3

↩ Retour à la calculatrice

Generate .gitignore files online free from 12 stack templates, merged with duplicates removed. Everything runs locally; nothing is uploaded.

FreeToolHub .gitignore Generator is a free browser-based tool — generate .gitignore files online free from 12 stack templates, merged with duplicates removed. No signup, no upload; everything runs locally in your browser.

À propos de cet outil

Qu'est-ce que cet outil ?

Générez des fichiers .gitignore gratuitement en ligne en combinant 12 modèles de stack : Node, Python, macOS, Windows, VS Code, JetBrains, React, Next.js, Go, Rust, Cloudflare et Django. Les règles sont fusionnées avec suppression des doublons. Copiez ou téléchargez instantanément. 100 % basé sur le navigateur.

12 stack templatesMerge & dedupeCopy or download100% local

Pourquoi des fichiers .gitignore combinés par stack

Chaque projet réel s'étend sur plusieurs écosystèmes à la fois : une application Next.js sur Windows dans VS Code a besoin d'ignorer les fichiers d'exécution, de filtrer les débris du système d'exploitation et d'exclure le bruit de l'éditeur simultanément. Au lieu de copier un modèle et d'ajouter manuellement le reste, sélectionnez tout ce qui s'applique et obtenez un fichier fusionné et dédoublé en une seule fois.

Douze modèles, un seul résultat net

Le générateur empile les modèles Node, Python, Go, Rust, React, Next.js, Django, Cloudflare, macOS, Windows, VS Code et JetBrains, puis supprime les règles en double qui se chevauchent entre eux. Le résultat est un .gitignore propre qui semble avoir été écrit par un humain - car la déduplication est ce qu'un humain attentif aurait fait de toute façon.

Garder le fichier fonctionnel après génération

Un .gitignore généré n'est que la moitié du travail — l'autre moitié est de le maintenir à jour à mesure que le projet grandit. Validez le fichier à la racine du dépôt immédiatement pour que chaque clone l'hérite, et résistez à la tentation d'ajouter des entrées trop larges comme *.log sans vérifier que votre pipeline de build ne produit pas d'artefacts dont quelqu'un a besoin. Quand un fichier est déjà suivi, l'ajouter à .gitignore ne fait rien : git continue de suivre les fichiers suivis, donc exécutez git rm --cached sur tout ce qui a été ajouté avant que la règle d'ignoration n'existe. Revenez sur le fichier lorsque vous ajoutez un nouvel outil à la stack — chaque nouvel environnement d'exécution apporte généralement ses propres répertoires de cache et de sortie — et préférez les modèles étroits aux caractères génériques pour que le fichier d'ignoration documente l'intention au lieu de cacher des accidents.

Questions fréquentes

Quels modèles devrais-je combiner ?

Commencez par votre environnement d'exécution (Node, Python, Go ou Rust), ajoutez votre framework si applicable (React, Next.js, Django), puis ajoutez votre éditeur (VS Code ou JetBrains) et votre système d'exploitation (macOS ou Windows). Un projet web typique utilise quatre à cinq modèles empilés ensemble.

Que signifie fusionné et dédoublé ?

Les modèles se chevauchent - Node, React et Next.js ignorent tous node_modules, par exemple. Le générateur fusionne votre sélection en un seul fichier et supprime les règles en double, pour que vous obteniez un .gitignore propre sans les blocs répétés que l'empilage des modèles bruts produirait.

Les modèles couvrent-ils les secrets et les fichiers d'environnement ?

Oui, les modèles d'environnement d'exécution incluent des modèles .env et des chemins d'accès courants aux informations d'identification. Mais aucun générateur ne peut connaître les secrets spécifiques de votre projet - révisez toujours la sortie avant votre premier commit, et ne vous fiez jamais à .gitignore seul comme seule mesure de sécurité.

Est-ce que .gitignore arrête de suivre les fichiers déjà commités ?

Non. Les règles d'ignoration n'affectent que les fichiers non suivis — tout ce que git suit déjà reste suivi. Pour arrêter de suivre un fichier précédemment commité, exécutez git rm --cached chemin/vers/fichier (ce qui le conserve sur disque), validez la suppression, et la règle d'ignoration prend effet à partir de ce moment.

Où devrait se trouver le fichier .gitignore ?

À la racine du dépôt pour les règles de portée projet. Git lit aussi les fichiers .gitignore dans les sous-répertoires pour les règles spécifiques à un dossier, et ~/.config/git/ignore (ou ~/.gitignore_global) pour les règles personnelles comme les restes d'éditeur qui ne devraient jamais entrer dans un dépôt. Ce générateur écrit le fichier racine — celui que vous validez et partagez.