Genera archivos .gitignore limpios y deterministas para todo tu stack en segundos. Combina reglas oficiales de upstream, elimina duplicados y copia o descarga configuraciones listas para producción sin rastreo.
Gratis · Generación en el navegador · Sin cuenta requerida
# 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
.LSOverrideExplora plantillas prediseñadas con patrones verificados y desglose de reglas de exclusión.
Diseñado específicamente para desarrolladores que exigen archivos de control de versiones limpios y deterministas:
La lógica pura de fusión elimina líneas idénticas preservando estrictamente las reglas de negación intencionales (!patrón) y el orden del archivo.
Plantillas oficiales de GitHub complementadas con stacks modernos curados (Vite, Astro, Svelte, Claude Code).
Ejecución 100% en TypeScript en el cliente. Tus selecciones y archivos generados se procesan en memoria y nunca se suben a ningún servidor.
Una interfaz limpia y libre de distracciones, con soporte impecable para modo oscuro y claro sin sobrecarga SaaS.
En el control de versiones con Git, los archivos no rastreados son candidatos para comitearse al preparar cambios. Un archivo .gitignore indica a Git exactamente qué archivos, carpetas y patrones deben excluirse deliberadamente del rastreo. Esto evita comprometer dependencias pesadas, claves secretas, binarios compilados y cachés del sistema operativo.
Los archivos locales como .env, .env.local y claves SSH privadas nunca deben entrar al repositorio para evitar filtraciones de seguridad.
Carpetas de gestores de dependencias como node_modules/, vendor/ o entornos virtuales de Python (.venv/) sobrecargan el repositorio y deben instalarse desde manifiestos.
Los artefactos intermedios generados por compiladores como dist/, target/, *.class y *.dll son reproducibles y no deben formar parte del historial de Git.
Las arquitecturas de software modernas rara vez se limitan a un solo lenguaje. Un entorno habitual combina un runtime (como Node.js o Python), un framework (como Next.js o Spring Boot), contenedores (Docker), herramientas de CI y desarrolladores en macOS, Windows o Linux con diferentes editores.
Un generador de .gitignore te permite seleccionar cada tecnología de tu stack y sintetizarlas en un único archivo listo para producción. En lugar de copiar y pegar fragmentos dispersos de tutoriales o repositorios distintos —lo que suele generar reglas duplicadas y errores de sintaxis— DotGitIgnore fusiona las reglas de manera determinista, elimina duplicados y genera un archivo normalizado listo para descargar o copiar.
Sigue este flujo de trabajo de cinco pasos para generar e implementar tu .gitignore:
Busca o selecciona tus tecnologías en el generador interactivo entre más de 321 plantillas oficiales.
Examina las vistas previas categorizadas y el recuento de reglas en el visor en tiempo real.
Haz clic en Copiar para llevar las reglas al portapapeles o en Descargar para guardar un archivo .gitignore limpio.
Guarda el archivo en el directorio raíz de tu repositorio con el nombre .gitignore.
Si ya habías comiteado archivos antes de crear las reglas, ejecuta git rm --cached para dejar de seguirlos.
Patrones representativos para los lenguajes de programación y frameworks más populares:
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
La coincidencia de patrones en Git utiliza sintaxis estilo glob para asociar rutas en el repositorio:
# commentLas líneas que comienzan con el símbolo de almohadilla # se tratan como comentarios y Git las ignora.
temp/Una barra final fuerza la coincidencia solo con directorios, no con archivos que tengan el mismo nombre.
*.logUn asterisco coincide con cero o más caracteres dentro de un mismo segmento de ruta (por ejemplo, *.log).
/buildUna barra inicial ancla el patrón directamente al directorio raíz donde reside el archivo .gitignore.
**/logsUn doble asterisco coincide recursivamente con directorios a cualquier nivel de profundidad en el árbol.
!important.logUn signo de exclamación niega un patrón previo, reincorporando un archivo descartado anteriormente.
Todo lo que necesitas saber sobre patrones de exclusión en Git, ubicación de archivos y flujos de trabajo.
Un archivo .gitignore es un documento de texto plano ubicado en la raíz de tu repositorio de Git. Especifica patrones y archivos no rastreados que Git debe ignorar deliberadamente, evitando que salidas de compilación, secretos locales, carpetas de dependencias y archivos temporales del sistema se suban al control de versiones.
Coloca el archivo .gitignore en el directorio raíz de tu proyecto (por ejemplo, /mi-proyecto/.gitignore). En esa ubicación, sus reglas se aplican de forma recursiva a todos los archivos y subdirectorios del repositorio. También puedes añadir archivos .gitignore adicionales en subcarpetas si necesitas reglas específicas para esas rutas.
Sí. Los proyectos modernos casi siempre combinan múltiples tecnologías (por ejemplo, Python + React + Docker + macOS + VS Code). DotGitIgnore te permite seleccionar tantas plantillas como necesites, resolviendo solapamientos y deduplicando reglas idénticas en un único archivo limpio.
Para ignorar un directorio completo y todo su contenido, añade una barra inclinada al final del nombre en tu .gitignore (por ejemplo, node_modules/ o build/). Un patrón sin barra final coincide tanto con archivos como con carpetas de ese nombre, mientras que la barra restringe la coincidencia exclusivamente a directorios.
Añadir un archivo a .gitignore no lo elimina de Git si ya fue rastreado en commits anteriores. Para dejar de rastrearlo sin borrarlo de tu disco local, ejecuta 'git rm --cached <archivo>' (o 'git rm -r --cached <directorio>/' para carpetas) y luego confirma el cambio con un commit.
Sí. El resultado generado por DotGitIgnore es texto de configuración estándar de Git. Puedes añadir libremente rutas específicas de tu proyecto, credenciales de entorno local, comentarios o desactivar reglas individuales directamente en el generador o en tu editor tras descargarlo.
Crea un archivo llamado .gitignore en la raíz de tu repositorio, añade las reglas relativas que deseas excluir (como dist/, .env o *.log) y guárdalo en Git ejecutando 'git add .gitignore && git commit -m "Add .gitignore"'. A partir de ese momento, Git ignorará los nuevos archivos no rastreados que coincidan con esas reglas.
Al inspeccionar el árbol de trabajo (por ejemplo, con 'git status' o 'git add .'), Git compara los archivos no rastreados con los patrones definidos en la jerarquía de archivos .gitignore. Si una ruta coincide con un patrón y no es reincorporada por una regla de negación posterior '!', Git omite el archivo del índice.
Un archivo .gitignore indica a Git qué archivos y carpetas no rastreados deben excluirse del control de versiones. Evita que cachés temporales, artefactos compilados, dependencias de terceros, archivos de configuración del sistema (.DS_Store) y credenciales secretas saturen los commits o se envíen a repositorios remotos.
Sí. En casi todas las circunstancias, el archivo .gitignore debe confirmarse en el repositorio para que las reglas de exclusión se compartan de forma homogénea con todos los colaboradores y pipelines de CI/CD. Para preferencias personales de tu editor local, utiliza .git/info/exclude o un archivo gitignore global.
La causa más común es que el archivo ya está siendo rastreado por Git. El archivo .gitignore solo evita que se agreguen archivos nuevos no rastreados; nunca deja de seguir archivos que ya estaban comiteados. Para corregirlo, elimina el archivo del índice con 'git rm --cached <archivo>' y comitea. Otras causas habituales son errores de sintaxis en los patrones o barras iniciales mal ubicadas.
Si .gitignore ya fue comiteado, agregarse a sí mismo no tiene efecto porque Git ya lo está rastreando. Si lo añades antes de hacer el primer commit, Git ignorará el propio archivo .gitignore, impidiendo compartir las reglas con tu equipo. En la práctica, nunca debes ignorar el archivo .gitignore.
Puedes probar si un archivo es ignorado ejecutando 'git check-ignore -v <ruta>'. Si está ignorado, Git mostrará el archivo .gitignore de origen, el número de línea y el patrón que coincide. También puedes ejecutar 'git status --ignored' para ver todos los archivos excluidos en tu directorio de trabajo.
La forma recomendada es crearlo antes del primer commit del proyecto, agrupar las reglas por categorías lógicas (dependencias, compilación, secretos locales), confirmar .gitignore en el control de versiones y gestionar herramientas personales en tu gitignore global. Usar DotGitIgnore garantiza partir de reglas limpias y deduplicadas diseñadas para tu stack.
Incluye carpetas de compilación (dist/, build/), directorios de dependencias (node_modules/, vendor/), credenciales de entorno (.env*), binarios compilados (*.class, *.o) y registros de ejecución (*.log). Nunca ignores código fuente, plantillas de configuración (como .env.example) ni archivos de bloqueo de dependencias (package-lock.json, Cargo.lock).
Sí. Git admite múltiples archivos .gitignore en la jerarquía de carpetas. Los patrones de un .gitignore en un subdirectorio se aplican solo a esa carpeta y sus elementos hijos, teniendo prioridad sobre los patrones de la raíz. Esto es especialmente útil en monorrepositorios con varios lenguajes o microservicios.
Para ignorar un archivo en cualquier lugar del proyecto, añade su nombre a .gitignore (por ejemplo, secreto.txt). Para limitarlo exclusivamente a la raíz, antepón una barra inclinada (/secreto.txt). Para ignorar un archivo anidado específico, escribe su ruta relativa desde la raíz (config/credenciales.json).
Añade .env y sus variantes locales (.env.local, .env.*.local) a tu .gitignore para evitar filtrar claves de API y contraseñas de bases de datos. Confirma siempre en Git un archivo saneado como .env.example con valores de muestra para que el equipo conozca las variables necesarias sin exponer secretos.
El archivo .gitignore se versiona en Git y se comparte con todos los colaboradores del repositorio, siendo ideal para reglas globales del proyecto (dependencias y builds). En cambio, .git/info/exclude es un archivo local dentro de .git/ que nunca se comitea ni se envía al servidor remoto, perfecto para patrones privados de tu máquina.
El signo de exclamación (!) niega un patrón previo para volver a incluir un archivo que había sido descartado por una regla anterior (por ejemplo, *.log seguido de !importante.log). Ten en cuenta que Git no puede reincorporar un archivo si su directorio contenedor ya está completamente ignorado.
Puedes forzar el seguimiento de un archivo ignorado utilizando el modificador -f (o --force): 'git add -f ruta/al/archivo'. Una vez agregado al índice y comiteado, el archivo permanecerá rastreado por Git aunque coincida con una regla de .gitignore, hasta que se descarte explícitamente con 'git rm --cached'.
Combina plantillas oficiales, elimina reglas repetidas y genera configuraciones de exclusión listas para producción en segundos.