Gere arquivos .gitignore limpos e determinísticos para toda a sua stack em segundos. Combine regras oficiais, elimine duplicatas e baixe configurações prontas para produção sem qualquer rastreamento.
Gratuito · Geração no navegador · Sem necessidade de conta
# Created by https://dotgitignore.com
# Edit at https://dotgitignore.com/generator?select=node,nextjs,docker,macos
### Node ###
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
.pnpm-debug.log*
### Next.js ###
.next/
out/
build/
dist/
### Environment Variables ###
.env
.env*.local
!.env.example
### Docker ###
.docker/
*.tar
### Operating System (macOS) ###
.DS_Store
.AppleDouble
.LSOverrideExplore modelos pré-configurados com regras verificadas e detalhamento de padrões.
Desenvolvido especialmente para quem precisa de arquivos de controle de versão limpos e determinísticos:
A lógica de união elimina linhas duplicadas preservando rigorosamente regras de negação (!padrão) e a ordem das regras.
Modelos oficiais do GitHub complementados por stacks modernas mantidas ativamente (Vite, Astro, Svelte, Claude Code).
Processamento completo em TypeScript no cliente. Suas tecnologias e arquivos gerados ficam apenas na memória e nunca são enviados para servidores.
Interface técnica direta ao ponto, sem distrações, com suporte fluido a Tema Escuro e Claro sem excessos de SaaS.
No Git, arquivos não rastreados podem ser comitados acidentalmente. Um arquivo .gitignore instrui o Git sobre quais arquivos, pastas e padrões devem ser excluídos. Isso evita o commit de dependências gigantescas, credenciais sensíveis, binários compilados e caches do sistema.
Arquivos de configuração local como .env, .env.local e chaves privadas SSH nunca devem entrar no controle de versão.
Pastas como node_modules/, vendor/ ou ambientes virtuais Python (.venv/) sobrecarregam repositórios e devem ser instaladas a partir dos manifestos.
Arquivos intermediários como dist/, target/, *.class e *.dll são produtos reproduzíveis e não pertencem ao histórico do Git.
A arquitetura de software atual raramente depende de uma única tecnologia. Um projeto típico combina ambientes de execução (Node.js, Python), frameworks (Next.js, Spring Boot), contêineres (Docker), CI/CD e desenvolvedores em diferentes sistemas operacionais com diversos editores.
Um gerador de .gitignore permite selecionar todas as tecnologias da sua stack e uni-las em um arquivo limpo e pronto para produção. Em vez de colar trechos soltos da internet, o DotGitIgnore mescla regras de forma determinística, deduplica linhas idênticas e entrega um arquivo confiável.
Siga este fluxo de 5 passos para gerar e aplicar o .gitignore no seu projeto:
Busque ou selecione tecnologias no gerador entre mais de 321 modelos selecionados.
Inspecione os padrões categorizados e a contagem de regras na visualização em tempo real.
Clique em Copiar para a área de transferência ou Baixar para salvar um arquivo limpo.
Salve o arquivo na raiz do repositório com o nome exato .gitignore.
Se arquivos já foram comitados antes do .gitignore, execute git rm --cached para parar de rastreá-los.
Padrões de exclusão representativos para as principais linguagens e frameworks:
node_modules/ dist/ npm-debug.log* .env .env.local
__pycache__/ *.py[cod] .venv/ dist/ *.egg-info/
target/ *.class *.jar *.war .sts4-cache/
[Ll]ibrary/ [Tt]emp/ [Oo]bj/ [Bb]uild/ *.csproj
.terraform/ *.tfstate *.tfstate.* crash.log override.tf
*.pid docker-compose.override.yml .docker/ *.tar
A correspondência de padrões no Git utiliza sintaxe estilo glob para casar caminhos:
# commentLinhas iniciadas com cerquilha # são consideradas comentários e ignoradas pelo Git.
temp/Uma barra final restringe a correspondência apenas a diretórios, e não a arquivos de mesmo nome.
*.logUm asterisco corresponde a zero ou mais caracteres em um segmento de caminho. Ex: ignora *.log.
/buildUma barra inicial ancora o padrão ao diretório raiz onde o arquivo .gitignore se localiza.
**/logsDois asteriscos correspondem a diretórios recursivamente em qualquer nível da árvore.
!important.logUma exclamação (!) nega um padrão anterior, reincluindo um arquivo anteriormente ignorado.
Tudo o que você precisa saber sobre sintaxe de exclusão no Git, locais de arquivos e fluxos de trabalho.
Um arquivo .gitignore é um documento de texto simples colocado na raiz do seu repositório Git. Ele define arquivos e padrões que o Git deve ignorar deliberadamente, evitando que saídas de build, variáveis de ambiente locais, pastas de dependências e arquivos temporários do sistema sejam enviados ao controle de versão.
Coloque o arquivo .gitignore no diretório raiz do seu projeto (por exemplo, /meu-projeto/.gitignore). Na raiz, suas regras se aplicam recursivamente a todos os arquivos e subpastas do repositório. Você também pode adicionar arquivos .gitignore adicionais em subpastas se precisar de regras específicas para caminhos determinados.
Sim. Projetos modernos quase sempre combinam várias tecnologias (por exemplo, Python + React + Docker + macOS + VS Code). O DotGitIgnore permite selecionar quantos modelos você precisar, resolvendo sobreposições e deduplicando regras idênticas em um único arquivo limpo.
Para ignorar um diretório inteiro e todo o seu conteúdo, adicione uma barra no final do nome em seu arquivo .gitignore (por exemplo, node_modules/ ou build/). Um padrão sem barra final casa tanto com arquivos quanto com pastas de mesmo nome, enquanto a barra restringe a regra apenas a diretórios.
Adicionar um arquivo ao .gitignore não o remove do Git se ele já foi comitado em versões anteriores. Para parar de rastreá-lo sem apagá-lo do seu disco local, execute 'git rm --cached <arquivo>' (ou 'git rm -r --cached <pasta>/' para pastas) e confirme com um commit.
Sim. O conteúdo gerado pelo DotGitIgnore é texto de configuração padrão do Git. Você pode adicionar caminhos próprios do projeto, personalizar segredos de ambiente, incluir comentários ou desativar regras livremente no gerador ou no seu editor de código após o download.
Crie um arquivo chamado .gitignore na raiz do repositório, adicione as regras relativas que deseja excluir (como dist/, .env ou *.log) e comite o arquivo no Git com 'git add .gitignore && git commit -m "Add .gitignore"'. A partir daí, o Git ignorará novos arquivos não rastreados que correspondam a essas regras.
Ao verificar o diretório de trabalho (por exemplo, durante 'git status' ou 'git add .'), o Git compara os arquivos não rastreados com os padrões definidos na hierarquia do .gitignore. Se um arquivo corresponder a um padrão e não for resgatado por uma regra de negação '!', o Git o ignora na indexação.
Um arquivo .gitignore instrui o Git sobre quais arquivos e pastas não rastreados devem ser excluídos do controle de versão. Ele impede que caches temporários, binários compilados, pacotes de terceiros, arquivos do sistema operacional (.DS_Store) e senhas secretas poluam os commits ou sejam enviados a repositórios remotos.
Sim. Em praticamente todas as situações, o .gitignore deve ser comitado no repositório para que todos os colegas de equipe e pipelines de CI/CD compartilhem as mesmas regras. Para preferências pessoais do seu editor local, utilize o arquivo .git/info/exclude ou um gitignore global.
O motivo mais frequente é que o arquivo já está sendo rastreado pelo Git. O .gitignore só atua em arquivos que ainda não foram comitados. Para corrigir, remova o arquivo do índice com 'git rm --cached <arquivo>' e comite. Outras causas comuns são erros de sintaxe nos padrões ou barras iniciais no local errado.
Se o .gitignore já foi comitado, adicionar a si mesmo não tem efeito porque o Git já o está rastreando. Se você o adicionar antes do primeiro commit, o Git ignorará o próprio arquivo, impedindo que você o compartilhe com seu time. Na prática, nunca se deve ignorar o .gitignore.
Você pode testar se um arquivo está sendo ignorado com o comando 'git check-ignore -v <caminho>'. Se estiver ignorado, o Git exibirá o arquivo .gitignore de origem, o número da linha e o padrão correspondente. Execute também 'git status --ignored' para listar todos os arquivos excluídos.
Crie o arquivo antes de fazer o primeiro commit do projeto, organize as regras em grupos lógicos (dependências, compilação, credenciais locais), versione o .gitignore no Git e configure ferramentas pessoais no seu gitignore global. O DotGitIgnore ajuda você a iniciar com regras limpas e deduplicadas.
Inclua diretórios de build (dist/, build/), pastas de dependências (node_modules/, vendor/), credenciais de ambiente (.env*), binários gerados (*.class, *.o) e logs de execução (*.log). Nunca ignore código-fonte, exemplos de configuração (.env.example) ou arquivos de lock de dependências.
Sim. O Git aceita múltiplos arquivos .gitignore na árvore de diretórios. Os padrões de um .gitignore em uma subpasta afetam apenas ela e suas pastas filhas, sobrepondo-se às regras da raiz. Isso é extremamente útil em monorepos com múltiplas linguagens ou microsserviços.
Para ignorar um arquivo em qualquer local do projeto, adicione seu nome ao .gitignore (por exemplo, segredo.txt). Para restringi-lo apenas à raiz, use uma barra no início (/segredo.txt). Para ignorar um arquivo em uma pasta específica, declare o caminho relativo (config/credenciais.json).
Adicione .env e variantes (.env.local, .env.*.local) ao seu .gitignore para evitar vazar chaves de API e credenciais de bancos de dados. Comite sempre um arquivo como .env.example com valores fictícios para orientar a equipe sobre as variáveis requeridas sem expor dados confidenciais.
O arquivo .gitignore é versionado no Git e compartilhado com todos os colaboradores, ideal para regras do projeto (como dependências e builds). Já o .git/info/exclude fica dentro de .git/ na sua máquina, nunca é comitado ou enviado remotamente, sendo perfeito para regras estritamente pessoais.
O ponto de exclamação (!) serve para negar um padrão, ou seja, reativar o rastreamento de um arquivo excluído por uma regra anterior (por exemplo, *.log seguido de !importante.log). Lembre-se: o Git não consegue reativar um arquivo se a pasta que o contém estiver totalmente ignorada.
Você pode forçar a adição de um arquivo ignorado com o argumento -f (ou --force): 'git add -f caminho/do/arquivo'. Depois de comitado, o arquivo continuará sendo rastreado pelo Git mesmo correspondendo a regras do .gitignore, até que seja desvinculado com 'git rm --cached'.
Combine modelos oficiais, elimine regras repetidas e gere configurações do Git prontas para produção em segundos.