Git Flow: qué es, ramas y comandos (y cuándo no usarlo)
¿Qué es Git Flow?
A lo largo de la jornada ejecutamos muchas veces los mismos comandos de Git: checkout, merge, push, pull, crear ramas y borrarlas. Git Flow (también escrito gitflow o git-flow) pone orden en todo eso: es un modelo de ramas que dice qué ramas usar, de dónde sale cada una y dónde se fusiona.
El nombre se usa para dos cosas distintas:
- El modelo de ramas. Lo publicó Vincent Driessen en 2010 en el artículo «A successful Git branching model». Dice qué ramas existen, de dónde sale cada una y dónde se fusiona.
- La herramienta
git-flow. Es un conjunto de extensiones de Git que aplican ese modelo con un solo comando. En lugar de crear la rama, cambiarte a ella, fusionarla y borrarla a mano, escribesgit flow feature finishy lo hace por ti.
Piensa en la cocina de un restaurante. Lo que sale a la sala tiene que estar perfecto (main). En la mesa de trabajo se preparan los platos del próximo menú (develop). Cada cocinero prepara su parte en su propia tabla (feature), antes de servir hay un último repaso en el pase (release), y si a un cliente le llega un plato mal, se rehace al momento sin esperar al menú siguiente (hotfix). El símil se queda corto en una cosa: en Git las «tablas» pueden durar semanas, y cuanto más duran, más cuesta juntarlas después.
Ramas en Git Flow

Diagrama: «A successful Git branching model», de Vincent Driessen, con licencia CC BY-SA 4.0. Sin modificaciones. En el diagrama original la rama de producción se llama master.
Hay dos ramas que viven siempre y cuatro de apoyo que se crean y se borran. Cómo listarlas y limpiar las que ya no hacen falta, en ramas locales en Git.
Las dos ramas principales
main (antes master). Todo lo que hay aquí está listo para producción. Cada vez que se incorpora código a main, por definición, hay una nueva versión, y se marca con una etiqueta (tag) como 1.0.0.
develop. Contiene el código que formará la siguiente versión planificada. Es donde se juntan las funcionalidades terminadas.
Las ramas de apoyo
| Rama | Para qué sirve | Sale de | Se fusiona en | Nombre |
|---|---|---|---|---|
feature |
Una funcionalidad nueva | develop |
develop |
feature/<nombre> |
release |
Preparar una versión: últimos ajustes y correcciones | develop |
main y develop |
release/<versión> |
hotfix |
Corregir un fallo urgente en producción | main |
main y develop |
hotfix/<versión> |
support |
Mantener una versión antigua que aún se usa | main o una etiqueta |
No vuelve a fusionarse de forma automática | support/<nombre> |
Algunos detalles que conviene saber:
- Feature. Puede llamarse como quieras, salvo con los nombres de las demás ramas. Mientras dura, nadie toca
developpor ti. - Release. En ella solo se corrigen fallos y se ajusta lo necesario para publicar (por ejemplo, el número de versión). Las funcionalidades nuevas esperan a la siguiente versión.
- Hotfix. Es como una release, pero sin planificar. Driessen añade una excepción: si en ese momento hay una rama
releaseabierta, el hotfix se fusiona en esa release en lugar de endevelop, porque la release acabará llegando adevelop. - Support. El artículo de Driessen no la incluye: la añadieron las herramientas. Sirve para mantener versiones antiguas que todavía están en uso, por ejemplo una
1.xmientras el resto avanza en la2.x. Si solo tienes una versión en producción, no la necesitas. - Los nombres. Driessen usaba guion (
release-1.2,hotfix-1.2.1). Las herramientas usan prefijos con barra (release/1.2,hotfix/1.2.1), que muchas interfaces muestran como carpetas.
Instalar git-flow
La herramienta original de Driessen (nvie/gitflow) está archivada desde octubre de 2025 y su página remite a git-flow-next, una reescritura en Go mantenida por Tower, la empresa del cliente de Git del mismo nombre. La versión más popular durante años, git-flow (AVH Edition), está archivada desde junio de 2023.
| Sistema | Comando | Qué instala |
|---|---|---|
| macOS y Linux con Homebrew | brew install git-flow-next |
git-flow-next |
| Windows | winget install GitTower.GitFlowNext o scoop install git-flow-next |
git-flow-next |
| Linux sin Homebrew | Descarga el binario de su página de versiones (ver abajo) | git-flow-next |
| Debian y Ubuntu | sudo apt install git-flow |
AVH Edition 1.12.3, sin mantenimiento |
En Linux sin Homebrew, descarga el binario y cópialo a una carpeta del PATH (cambia v2.1.0 por la última versión y amd64 por arm64 si tu equipo es ARM):
curl -sL https://github.com/gittower/git-flow-next/releases/download/v2.1.0/git-flow-next-v2.1.0-linux-amd64.tar.gz | tar xz -C /tmp
sudo install /tmp/git-flow /usr/local/bin/git-flow
git flow version # 2.1.0 (git-flow-next)
Cómo usar git-flow: los comandos
Los ejemplos están ejecutados con git-flow-next 2.1.0. Con la AVH Edition los comandos son los mismos; cambian los mensajes y la rama se llama master.
- Inicializa el repositorio una vez:
git flow init. - Para cada funcionalidad:
feature start, tus commits yfeature finish. - Para publicar una versión:
release startyrelease finish. - Para un fallo urgente en producción:
hotfix startyhotfix finish.
Inicializar un proyecto con git flow init
mkdir nombre-proyecto
cd nombre-proyecto
git init
git flow init --defaults
--defaults (o -d) acepta los nombres por defecto sin preguntar. Sin esa opción, git flow init te pregunta uno a uno los nombres de las ramas y los prefijos; si pulsas Enter en todos, el resultado es el mismo.
Initializing git-flow with default settings
Created branch 'main'
Created branch 'develop'
Git flow has been initialized
Este comando hace por ti:
- Crea la rama
main(masteren la AVH Edition). - Crea la rama
develop. - Te deja en la rama
develop. - Guarda los nombres y prefijos en la configuración del repositorio (
.git/config).
Empezar una feature: git flow feature start
git flow feature start login
Created branch 'feature/login' from 'develop'
Crea la rama feature/login a partir de develop y te cambia a ella. Ahora trabajas con normalidad: editas, haces git add y git commit las veces que haga falta.
Terminar una feature: git flow feature finish
git flow feature finish login
Este comando hace por ti:
- Fusiona la rama
feature/loginendevelop. - Borra la rama
feature/login. - Te deja en la rama
develop.
Así lo resume la AVH Edition:
Summary of actions:
- The feature branch 'feature/newfeature' was merged into 'develop'
- Feature branch 'feature/newfeature' has been locally deleted
- You are now on branch 'develop'
Si estás en la propia rama de la feature, basta con git flow finish: git-flow-next detecta qué rama es.
Publicar una versión: git flow release
git flow release start 1.0.0
# ajusta el número de versión, corrige los últimos fallos y haz commit
git flow release finish -m "Versión 1.0.0" 1.0.0
release finish fusiona la rama release/1.0.0 en main, crea la etiqueta 1.0.0 con el mensaje que indicas en -m, lleva esos cambios a develop, borra la rama de la release y te deja en develop.
Qué es un hotfix y cómo se hace: git flow hotfix
Un hotfix es la vía rápida para arreglar algo que ya está en producción, sin arrastrar lo que aún está a medias en develop:
git flow hotfix start 1.0.1
# corrige el fallo y haz commit
git flow hotfix finish -m "Versión 1.0.1" 1.0.1
La rama sale de main. Al terminar, se fusiona en main, se crea la etiqueta 1.0.1 y la corrección llega también a develop, para que el fallo no reaparezca en la siguiente versión.
Chuleta de comandos
| Quiero… | Comando |
|---|---|
| Preparar el repositorio | git flow init --defaults |
| Empezar una funcionalidad | git flow feature start <nombre> |
| Subirla al remoto para compartirla | git flow feature publish <nombre> |
| Terminarla | git flow feature finish <nombre> |
| Ver las features abiertas | git flow feature list |
| Preparar una versión | git flow release start <versión> |
| Publicarla con etiqueta | git flow release finish -m "<mensaje>" <versión> |
| Arreglar producción | git flow hotfix start <versión> y git flow hotfix finish <versión> |
| Mantener una versión antigua | git flow support start <nombre> <etiqueta> |
Cuándo no usar Git Flow
No hay soluciones mágicas: mira tu contexto.
En 2020, diez años después de publicarlo, Driessen añadió una «nota de reflexión» al principio de su artículo. En resumen, dice esto:
- Git Flow se hizo tan popular que muchos equipos lo tratan como un estándar, y también, por desgracia, como un dogma o una solución para todo.
- Hoy se desarrollan sobre todo aplicaciones web, que se entregan de forma continua, no se vuelven a versiones anteriores y no obligan a mantener varias versiones a la vez. No es el tipo de software que él tenía en mente.
- Si tu equipo hace entrega continua, recomienda un flujo mucho más simple, como GitHub flow, en lugar de forzar Git Flow.
- Si tu software tiene versiones explícitas o necesitas mantener varias versiones en uso, Git Flow puede seguir encajando tan bien como siempre.
- Y termina: no hay panaceas; considera tu contexto y decide por ti mismo.
Martin Fowler, en «Patterns for Managing Source Code Branches», añade un matiz útil: Git Flow no dice cuánto deben durar las ramas feature, y por tanto tampoco cada cuánto se integra el trabajo. Cuanto más vive una rama separada, más cambios se acumulan y más difícil es juntarla después.
Git Flow encaja si…
- Publicas versiones numeradas cada cierto tiempo
- Mantienes varias versiones a la vez (por ejemplo, software instalado en casa de cada cliente)
- Necesitas una fase de preparación antes de cada versión
Mejor algo más simple si…
- Despliegas a producción varias veces por semana o al día
- Solo hay una versión en producción, como en la mayoría de webs
- Tus features viven semanas y fusionarlas siempre da conflictos
Las alternativas: GitHub flow y trunk-based development
- GitHub flow. Una sola rama principal y ramas cortas para cada cambio. Abres una pull request, alguien la revisa, pasan las comprobaciones automáticas y se fusiona en la rama principal. Sin
develop, sinreleasey sinhotfix: un arreglo urgente es un cambio más. - Trunk-based development (desarrollo sobre el tronco). Todo el equipo integra en la rama principal (el «tronco») muy a menudo. Según la guía del programa de investigación DORA, eso significa tres o menos ramas activas, ramas que duran horas y no días, y fusionar en el tronco al menos una vez al día. DORA relaciona estas prácticas con un mejor rendimiento en la entrega de software.
Las dos se apoyan en la integración continua: cada cambio se junta pronto con el de los demás y una batería de tests automáticos confirma que nada se ha roto. Sin tests fiables, integrar a diario da miedo, y las ramas largas vuelven a parecer la opción segura. Por eso estas alternativas van de la mano de prácticas como el TDD. Tienes más contexto en Desarrollo continuo de software.
git-flow-next también contempla estos flujos: git flow init --preset=github configura una rama principal con ramas feature, sin develop.
Tu siguiente paso
- Si publicas versiones numeradas, prueba Git Flow en un repositorio de juguete:
git flow init --defaults, una feature y una release. En cinco minutos verás todo el ciclo. - Si despliegas de forma continua, empieza por ramas cortas que se fusionen en el día, y deja Git Flow para cuando de verdad necesites mantener varias versiones.
- En ambos casos, unos mensajes de commit consistentes hacen el historial mucho más fácil de leer: te lo cuento en Git Commitizen.
Para seguir aprendiendo
- Chuleta de git-flow en español, de Daniel Kummer (basada en la AVH Edition).
- Qué es git-flow, en Aprendegit.com.
- Chuleta de git-flow en un gist, de seyhunak.
Fuentes
Comprobado en noviembre de 2026:
- Vincent Driessen, «A successful Git branching model» (5 de enero de 2010), con su nota de reflexión del 5 de marzo de 2020. Ramas, orígenes, destinos, nombres, uso de
--no-ffy licencia del diagrama (CC BY-SA 4.0). La nota se resume, no se cita literalmente. - git-flow-next 2.1.0 (8 de septiembre de 2026): README,
CONFIGURATION.md, documentación y guía del flujo Gitflow (propósito de las ramassupport). Licencia BSD-2-Clause. - nvie/gitflow: archivado el 14 de octubre de 2025, remite a git-flow-next.
- git-flow (AVH Edition): archivado el 19 de junio de 2023. En Debian 13 (paquete
git-flow1.12.3-3) y Ubuntu 26.04 (1.12.3-3build1),aptsigue instalando esta versión. - Martin Fowler, «Patterns for Managing Source Code Branches» (28 de mayo de 2020), apartado sobre Git-flow.
- DORA, «Trunk-based development».
- GitHub Docs, «GitHub flow».
Ejecutado en contenedores Docker debian:trixie con Git 2.47.3: git flow init --defaults, --preset=classic, feature start/finish (con y sin --no-ff), feature list, release start/finish -m, hotfix start/finish y support start con git-flow-next 2.1.0 (binario linux-amd64 de su página de versiones), y git flow init -d, feature start/finish y release start/finish con git-flow AVH Edition 1.12.3 (paquete de Debian). La instalación con Homebrew, WinGet y Scoop se ha comprobado solo en la documentación oficial. La captura de feature finish es la del artículo original de Rubén.