.gitignore Generator

Every repository needs a .gitignore — the plain text file that tells Git which files are build junk, which folders are only there for your editor, and which values must never be committed at all. Compiled output, dependency directories, logs, environment files and private keys all get named in it. In practice the file is usually written once, in a hurry, and then silently fails to cover the next build tool or editor you adopt. The result is the classic mess of an overgrown ignore list, or the worse accident of a missing one: build artifacts, API keys or local configuration accidentally pushed to a shared remote.

This generator turns that chore into a two-minute task. Instead of hunting templates across GitHub repositories, you search a catalog of more than 40 curated .gitignore entries, tick the ones that match your stack, and press Generate. The tool merges every selected template, adds a readable header above each block, removes any pattern that appears twice, appends your own custom rules under a dedicated section, and hands you one tidy file ready to drop into the repository root.

The catalog is organised into four groups so a whole stack can be assembled in seconds. Languages and runtimes cover Node.js, Python, Java, Ruby, Go, Rust, C, C++, C#, PHP, Swift, Kotlin, Scala, Dart, Lua, R, Julia and Haskell. Frameworks cover Django, Flask, Ruby on Rails, Laravel, Spring Boot, Next.js, Nuxt, Angular, Vite, Express and .NET Core. IDEs and editors cover VS Code, JetBrains, Eclipse, NetBeans, Xcode, Vim, Emacs, Sublime Text and Android Studio. Operating systems cover macOS, Windows and Linux. Search is forgiving and understands aliases — typing js finds Node.js, intellij finds JetBrains, mac finds macOS, golang finds Go — so there is no need to memorise exact names. You can also combine templates freely: selecting ten toolkits at once is just as easy as selecting two.

A few switches shape the output without changing its behaviour. Include template headers keeps the helpful ### comments that say which toolkit each block belongs to, so a teammate reading the file instantly understands what each section protects. Group by category adds #### headings above the four groups, which is especially useful when you merge a large, polyglot stack and want the file to read top to bottom in order. Sort templates alphabetically reorders the merged blocks by template name instead of catalog order, handy when you prefer to scan rules alphabetically. Remove duplicate lines keeps the file compact when two templates repeat a pattern — the Vite template and the Node.js template, for example, both ignore npm-debug.log*, and only the first occurrence survives. End file with newline appends the trailing newline that many linters and diff tools expect. Whatever you pick, the preview and the statistics refresh instantly, so it is easy to experiment and compare.

The statistics tell you exactly what you are looking at: how many templates are selected, how many headed sections the output contains, how many lines it spans, and — the number that matters — how many real ignore patterns it holds, counting only non-comment, non-blank lines. This programmatic view is the difference between blindly pasting a template and knowing what your entire stack now ignores. Note that in .gitignore semantics a line starting with # is a comment, not a pattern, so the headers and notes inside the templates are invisible to version control; only the actual patterns do the work. Patterns from different templates are safe to combine because each line applies independently — a directory pattern like node_modules/ ignores that folder everywhere in the repository, and a negation line like !.vscode/settings.json re-includes one specific file while the rest of the editor folder stays ignored. Because Git evaluates lines in order and later negation re-includes candidates, the generated file keeps every template block intact, and every selected pattern is preserved exactly as it was written in its source template.

The generator runs entirely in the browser: the templates are bundled with the page, merging is pure JavaScript, and no network request is made. That makes it safe for private or pre-release work and means it keeps working offline. When the output looks right, copy it to the clipboard or download it as .gitignore, place it in the repository root next to the .git folder, and commit it so every contributor starts from the same rules. For a quick tour of the output, click Load sample — it pre-selects a typical Node.js plus Python plus Vite plus editor stack and generates the file immediately, so you can see the headers, the category grouping and the statistics before writing a single line of your own. Afterwards, clear the selection, tick exactly the tools your repository uses, add any project-specific rules, and press Generate again — the preview updates in place, and the exported file is ready to make your next commit clean.

• 40+ curated templates across four groups: languages and runtimes, frameworks, IDEs and editors, operating systems.
• Instant search with aliases — js finds Node.js, intellij finds JetBrains, mac finds macOS.
• Endless combination — tick any number of templates and merge them into a single file.
• Section headers — each template (and your Custom block) is introduced by a readable ### comment.
• Category grouping — optional #### headings above each of the four groups.
• Alphabetical sorting — reorder merged blocks by template name instead of catalog order.
• Automatic de-duplication — identical patterns are written once, even when templates repeat them.
• Custom lines — append your own rules, such as secrets or local folders, under their own section.
• Live statistics — templates, sections, lines and real ignore-pattern counts update on every change.
• Sample, Check all shown and Clear — fast controls for exploring the catalog and resetting.
• Copy, download and print — get the result as .gitignore in one click, fully client-side.

1. Choose your stack. Type the tools you use into the search box — Node.js, Django, Go, Vite, VS Code — and the catalog narrows as you type.
2. Tick the matching templates — one for each language, framework, editor and operating system in the project.
3. Add custom rules in the Custom lines box, for example .env.local, *.pem or a local build folder.
4. Tune the options — template headers, category grouping, template sorting, duplicate removal and the trailing newline.
5. Generate .gitignore and read the preview together with its statistics.
6. Copy or download the result and save it as .gitignore in the repository root.
7. Commit it — git add .gitignore then commit, so every teammate starts from the same rules.

Example 1 — Node.js API. Select Node.js, Express, VS Code and macOS. The output covers node_modules, debug logs, dist output and .DS_Store, with a header for each toolkit.

Example 2 — Python data project. Select Python, Django, JetBrains and Windows. The file handles __pycache__, virtual environments, .env, db.sqlite3, editor config and Thumbs.db.

Example 3 — Go microservice. Select Go, VS Code and Linux. Compiled binaries, test artifacts, the vendor folder and editor and OS noise are all ignored.

Example 4 — Full-stack monorepo. Select Node.js, Vite, Next.js, JetBrains, macOS and Windows. Category headings group the rules so each toolkit's section is easy to audit.

Example 5 — Minimal web app. Select only Vite, then add a Custom line scaffold. The result is a short, readable baseline without template clutter.

Example 6 — Protecting secrets. Generate Node.js plus macOS, then add .env.* and *.pem as custom lines to keep credentials and private keys out of history.

• Instant, complete rules — no need to remember every framework's ignore list or hunt down template files.
• Fewer noise commits — build artifacts, caches and editor clutter stay untracked from day one.
• Safer repositories — secrets and local configuration can be ignored in seconds.
• One file for the whole stack — any number of templates merged cleanly with no conflicts.
• Tidy, maintainable output — headers, category grouping and de-duplication keep the file readable for reviewers.
• Nothing uploaded — generation runs entirely in your browser, which even fits private codebases.
• No installs or accounts — works on any device with a browser, offline included.