What happens if I select multiple presets that share the same pattern?

Each pattern is only included once. If two presets both list the same ignore pattern, it appears under whichever preset's section comes first in the output, and isn't duplicated further down.

Does the IDE preset cover every editor?

It covers the two most common cases: VS Code's project-local `.vscode/` folder (with its `extensions.json` explicitly un-ignored, a common convention for sharing recommended extensions) and JetBrains IDEs' `.idea/` folder, plus general OS clutter files like `.DS_Store` and `Thumbs.db`.

Is this the same as GitHub's official gitignore templates?

It's inspired by the same common patterns as GitHub's github/gitignore repository and gitignore.io, but each preset here is a curated, representative subset rather than the full upstream template. For an exhaustive, officially maintained list, cross-check against github.com/github/gitignore.

Can I combine, say, Node and React/Next.js?

Yes, presets are additive. A typical Next.js project would select both Node (for node_modules/ and npm logs) and React/Next.js (for .next/, out/, and Next-specific build artifacts) together, plus IDE files if desired.

.gitignore Generator - Combine Presets Into One File

Overview

Introduction

Most .gitignore files end up assembled from a copy-pasted GitHub template plus a few extra lines someone added after accidentally committing an IDE folder, and it's rarely revisited once it exists.

This tool builds a .gitignore from a small set of curated presets you toggle on, node_modules, Python bytecode, build output directories, and IDE clutter, combined into one deduplicated file.

What Is .gitignore Generator?

A multi-select .gitignore generator covering eight common presets: Node, Python, Java, .NET, Go, Rust, React/Next.js, and IDE files (VS Code, IntelliJ, plus OS files like .DS_Store).

Selecting any combination of presets merges their patterns into a single file, with each preset's patterns grouped under its own labeled comment section.

How .gitignore Generator Works

Each preset maps to a fixed, curated list of ignore patterns representative of that ecosystem's common build artifacts and dependency directories.

When you select multiple presets, their pattern lists are concatenated in the order presented, and any pattern that already appeared in an earlier preset is silently skipped from later ones to avoid duplicate lines.

When To Use .gitignore Generator

Use it right after creating a new repository, before your first commit, to avoid accidentally committing node_modules/, build output, or your IDE's project folder.

It's also useful when adding a new language or tool to an existing project (e.g. adding a Python microservice to a Node monorepo) and you need to extend an existing .gitignore.

Often used alongside GitHub Actions Workflow Generator, Git Hooks Generator and Conventional Commit Message Generator.

Features

Advantages

Combines multiple ecosystem presets into one deduplicated file in a single step, rather than manually merging several downloaded templates.
Groups the output into clearly labeled sections, making it easy to see exactly which preset contributed which lines.
Covers the presets most relevant to typical web/app development stacks (Node, React/Next.js) alongside common backend languages (Python, Java, Go, Rust, .NET).

Limitations

Each preset is a curated, representative subset, not the full exhaustive upstream GitHub template, unusual tooling within an ecosystem may need extra manual lines.
Doesn't detect your actual project structure, it produces a generic file for the ecosystems you select, not a file audited against your repository's real contents.

Examples

Combining Node and IDE presets

Input

presets: Node, IDE files

Output

### Node ###
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
.pnpm-store/
dist/
coverage/
.env
.env.local

### IDE files (VS Code, IntelliJ) ###
.vscode/*
!.vscode/extensions.json
.idea/
*.iml
*.iws
.DS_Store
Thumbs.db

Each selected preset renders as its own labeled section, with patterns from later presets deduplicated against earlier ones.

Best Practices & Notes

Best Practices

Select every ecosystem actually present in your repository (e.g. both Node and Go for a monorepo with a JS frontend and a Go backend) rather than a single preset.
Run `git status` right after adding the generated .gitignore to confirm it actually excludes the files you expect, especially if the repository already has tracked files that should now be ignored (those need `git rm --cached` separately).
Add project-specific one-off patterns (like a local `.env.production` file) below the generated content rather than mixing them into the preset sections.

Developer Notes

Patterns are deduplicated using a single running Set across all selected presets, checked in preset-selection order, so overlapping entries (for example `.DS_Store` also being relevant across multiple ecosystem presets) only ever appear once, under whichever preset's section is emitted first. Each preset's pattern list is a fixed constant rather than fetched from a live template source, keeping the tool fully offline and deterministic.

.gitignore Generator Use Cases

Setting up a .gitignore immediately after `git init` on a new project
Adding IDE-specific ignores to a repository that only has a language-specific .gitignore so far
Building a .gitignore for a polyglot monorepo spanning multiple presets at once

Common Mistakes

Adding a .gitignore after files are already committed and assuming it retroactively removes them from version control, it only affects untracked files; already-tracked files need `git rm --cached` first.
Not including the IDE preset, so a personal .vscode/ or .idea/ folder with machine-specific settings ends up committed and creates noisy diffs for every teammate.

Tips

If your team wants to keep specific VS Code settings shared (like recommended extensions), the IDE preset's `!.vscode/extensions.json` line already carves out that one exception, add more `!` exceptions the same way for other files you want to keep.

.gitignore Generator