Juego de las ranas Flexbox CSS: Flexbox Froggy
Flexbox Froggy es el juego de las ranas de Flexbox CSS: en cada nivel escribes una o varias propiedades y las ranas se mueven hasta sus nenúfares. Flexbox es la forma de CSS de colocar elementos en una fila o en una columna y repartir el espacio entre ellos. Es como colocar libros en una estantería: decides si van juntos a la izquierda, separados o centrados, y qué pasa cuando la balda se llena.
En el juego, el estanque es el contenedor y las ranas son los elementos. Tú escribes las propiedades del estanque (y, en algunos niveles, de una rana) y ves al momento cómo se mueven.
Cómo se juega
- Abre flexboxfroggy.com/#es (el
#eslo pone en español). - Lee el enunciado: explica la propiedad nueva y sus valores.
- Escribe la propiedad en el editor y mira cómo se mueven las ranas.
- Cuando todas están en su nenúfar, pasa al siguiente nivel.
Hay tres dificultades: principiante (con explicaciones), intermedio (sin explicaciones) y experto (sin explicaciones y con los niveles en orden aleatorio). La primera vez, juega en principiante; para repasar unos días después, en experto.
Qué propiedades aprendes
| Propiedad | Para qué sirve | Niveles |
|---|---|---|
justify-content |
Reparte los elementos en el eje principal (en una fila, en horizontal) | 1–4 |
align-items |
Los alinea en el eje cruzado (en una fila, en vertical) | 5–7 |
flex-direction |
Elige fila o columna, y en qué sentido | 8–13 |
order |
Cambia el orden de un elemento sin tocar el HTML | 14–15 |
align-self |
Alinea un solo elemento | 16–17 |
flex-wrap |
Deja que los elementos pasen a otra línea | 18–19 |
flex-flow |
Atajo de flex-direction y flex-wrap |
20 |
align-content |
Reparte las líneas cuando hay varias | 21–24 |
Las propiedades de Flexbox Froggy, explicadas
Para que puedas probar cada propiedad fuera del juego, todos los ejemplos usan el mismo montaje: un estanque de 500 × 300 px y ranas de 50 × 50 px.
<div id="pond">
<div class="rana">1</div>
<div class="rana">2</div>
<div class="rana">3</div>
</div>
#pond {
display: flex;
width: 500px;
height: 300px;
}
.rana {
width: 50px;
height: 50px;
}
Debajo de cada ejemplo está dónde queda cada rana, medido en Google Chrome 157 sin interfaz: la distancia desde la esquina superior izquierda del estanque, en píxeles, como (izquierda, arriba).
Primero, los dos ejes
Flexbox trabaja sobre dos ejes:
- El eje principal es la dirección en la que se colocan los elementos. Por defecto es una fila, de izquierda a derecha.
- El eje cruzado es el perpendicular: en una fila, el vertical.
Todo lo demás depende de esto. justify-content mueve en el eje principal y align-items, en el cruzado. Si cambias la dirección a columna, los ejes giran con ella. El propio juego lo avisa en los enunciados de los niveles 10 (dirección invertida) y 11 (columna).
justify-content: repartir en la fila
Coloca los elementos a lo largo del eje principal. El juego enseña cinco valores:
flex-start: todos al principio (a la izquierda en una fila). Es el comportamiento por defecto.flex-end: todos al final (a la derecha).center: todos juntos en el centro.space-between: el primero pegado al principio, el último pegado al final y el mismo hueco entre cada par.space-around: el mismo hueco entre cada par, y en los bordes la mitad de ese hueco.
#pond {
display: flex;
justify-content: space-between;
}
flex-start 1:(0,0) 2:(50,0) 3:(100,0)
flex-end 1:(350,0) 2:(400,0) 3:(450,0)
center 1:(175,0) 2:(225,0) 3:(275,0)
space-between 1:(0,0) 2:(225,0) 3:(450,0)
space-around 1:(58.3,0) 2:(225,0) 3:(391.7,0)
Fíjate en space-around: entre ranas hay 116,7 px de hueco y en cada borde, la mitad. Existe un sexto valor que el juego no usa, space-evenly, que deja el mismo hueco también en los bordes (en este montaje, la primera rana queda en 87,5 px).
align-items: alinear en vertical
Coloca los elementos en el eje cruzado, que en una fila es el vertical:
flex-start: arriba.flex-end: abajo.center: centrados en vertical.baseline: alineados por la línea base de su texto, la línea imaginaria sobre la que se apoyan las letras.stretch: estirados hasta ocupar todo el alto. El valor inicial esnormal, que en Flexbox se comporta comostretch; solo se nota si el elemento no tiene un alto fijo.
Para centrar una rana en el estanque necesitas las dos propiedades, una por eje:
#pond {
display: flex;
justify-content: center;
align-items: center;
}
1:(225,125)
Y para llevarla al centro del borde derecho:
#pond {
display: flex;
justify-content: flex-end; /* al final de la fila: a la derecha */
align-items: center; /* centrada en vertical */
}
1:(450,125)
Con align-items: flex-end las tres ranas bajan al fondo: quedan en (0,250), (50,250) y (100,250). Con stretch y sin height en las ranas, cada una mide 50 × 300 px.
flex-direction: fila o columna, y en qué sentido
Elige el eje principal:
row: fila en el sentido del texto (de izquierda a derecha en español). Es el valor por defecto.row-reverse: fila en sentido contrario.column: columna de arriba abajo.column-reverse: columna de abajo arriba.
#pond {
display: flex;
flex-direction: row-reverse;
}
1:(450,0) 2:(400,0) 3:(350,0)
Las ranas no solo cambian de orden: también cambian de lado. Con -reverse, el principio y el final se intercambian. Eso significa que, con row-reverse, flex-start está a la derecha y flex-end, a la izquierda:
#pond {
display: flex;
flex-direction: row-reverse;
justify-content: flex-end;
}
1:(100,0) 2:(50,0) 3:(0,0)
Y en columna, los ejes giran: justify-content pasa a mover en vertical y align-items, en horizontal.
#pond {
display: flex;
flex-direction: column;
justify-content: flex-end; /* ahora, abajo */
}
1:(0,150) 2:(0,200) 3:(0,250)
Con flex-direction: column y align-items: center, en cambio, la columna se centra en horizontal: las tres ranas quedan en x = 225.
order: cambiar el orden de una rana
Se escribe en el elemento, no en el contenedor. Todos los elementos empiezan con order: 0 y se colocan de menor a mayor; si empatan, en el orden del HTML. Un número mayor manda el elemento detrás y uno negativo, delante.
.rana:nth-child(3) {
order: -1;
}
1:(50,0) 2:(100,0) 3:(0,0)
La rana 3 pasa a ser la primera sin tocar el HTML.
align-self: alinear solo una rana
También va en el elemento. Acepta los mismos valores que align-items y manda sobre él para ese elemento:
#pond {
display: flex;
align-items: flex-start;
}
.rana:nth-child(2) {
align-self: flex-end;
}
1:(0,0) 2:(50,250) 3:(100,0)
Las ranas 1 y 3 siguen arriba; la 2 baja al fondo.
flex-wrap: dejar que salten de línea
Por defecto (nowrap), todos los elementos se quedan en una sola línea aunque no quepan. Para que quepan, los encoge: lo permite flex-shrink, que vale 1 por defecto. Con siete ranas de 100 px de ancho en un estanque de 500 px:
.rana {
width: 100px;
}
nowrap cada rana mide 71.4 px de ancho; las siete en una fila
wrap fila 1: ranas 1 a 5, en y = 0; fila 2: ranas 6 y 7, en y = 150
wrap-reverse fila 1: ranas 1 a 5, en y = 250; fila 2: ranas 6 y 7, en y = 100
nowrap: una sola línea (encogiendo si hace falta).wrap: los que no caben pasan a la línea siguiente.wrap-reverse: igual, pero las líneas se apilan en sentido contrario (la primera, abajo).
¿Por qué la segunda fila empieza en y = 150 y no en 50? Porque las dos líneas se reparten el alto del estanque. Eso lo controla align-content, un poco más abajo.
flex-flow: dirección y salto en una línea
Es un atajo para escribir flex-direction y flex-wrap juntos, separados por un espacio:
#pond {
display: flex;
flex-flow: column wrap;
}
/* equivale a */
#pond {
display: flex;
flex-direction: column;
flex-wrap: wrap;
}
Con nueve ranas de 100 px de alto, las dos versiones dan exactamente las mismas posiciones: tres columnas de tres ranas, en x = 0, 166,7 y 333,3. Chrome también acepta los dos valores en orden inverso (wrap column).
align-content: repartir las líneas
Cuando hay varias líneas, align-content decide cómo se reparten en el eje cruzado. Acepta flex-start, flex-end, center, space-between, space-around y stretch. Su valor inicial también es normal, que en Flexbox se comporta como stretch. Con las siete ranas de 100 px y flex-wrap: wrap:
#pond {
display: flex;
flex-wrap: wrap;
align-content: flex-start;
}
flex-start fila 1 en y = 0; fila 2 en y = 50
flex-end fila 1 en y = 200; fila 2 en y = 250
center fila 1 en y = 100; fila 2 en y = 150
space-between fila 1 en y = 0; fila 2 en y = 250
La diferencia con align-items es lo que mueve: align-items coloca cada elemento dentro de su línea; align-content mueve las líneas enteras.
Un detalle: el juego dice que con una sola línea align-content no tiene efecto. Según MDN, eso es exacto cuando el contenedor tiene flex-wrap: nowrap. Con flex-wrap: wrap, aunque todo quepa en una línea, sí la mueve: en la prueba, tres ranas con align-content: flex-end bajaron a y = 250 con wrap y se quedaron arriba con nowrap.
Si te atascas en un nivel de Flexbox Froggy
Estas pistas van por bloques de niveles y no dan la solución: te dicen qué mirar para que llegues tú. Se han contrastado con la definición de cada nivel en el código del juego.
Antes de nada, en cualquier nivel: pasa el cursor sobre el nombre de una propiedad en el enunciado para ver sus valores, y prueba un valor cada vez. El juego te dice al momento si las ranas están en su sitio.
- Niveles 1–4 (
justify-content). Fíjate en dónde está el espacio libre. ¿Todo a un lado? ¿Todo en el centro? ¿Ranas pegadas a los bordes o con aire también en los bordes? Cada caso es uno de los cinco valores. - Niveles 5–7 (
align-items). Si la rana tiene que moverse en horizontal y en vertical, necesitas dos líneas de CSS:justify-contentpara un eje yalign-itemspara el otro. - Niveles 8–13 (
flex-direction). Resuelve primero el orden y la dirección de las ranas; después, dónde van. Si el nivel usa una dirección-reverse, recuerda queflex-startyflex-endse intercambian. Si es una columna,justify-contentpasa a ser el vertical. El último del bloque necesita tres propiedades. - Niveles 14–15 (
order). Aquí escribes en una rana, no en el estanque. Cuenta en qué posición está ahora y en cuál tiene que acabar: todas empiezan en 0, y los números negativos también valen. - Niveles 16–17 (
align-self). Usa los mismos valores quealign-items, pero solo para una rana. En el 17 esa rana tiene que moverse en vertical y cambiar de puesto en la fila: combina dos propiedades. - Niveles 18–19 (
flex-wrap). Si las ranas están apretadas es que están en una sola línea: déjalas saltar. En el 19 te piden columnas, así que además de dejarlas saltar tienes que cambiar la dirección. - Nivel 20 (
flex-flow). Es el nivel anterior escrito en una sola propiedad. - Niveles 21–24 (
align-content). Si las ranas están bien colocadas entre sí pero todo el grupo está desplazado, mueve las líneas conalign-content, no conalign-items. El 23 combina una dirección yalign-content. El 24 junta casi todo lo que has visto: ve propiedad a propiedad, empezando por la dirección y el salto de línea, y mira cómo se mueven las ranas después de cada una.
Si después de las pistas sigues atascado, vuelve a la sección de esa propiedad en este artículo y prueba el ejemplo cambiando los valores.
Cómo sacarle partido
- Juega los 24 niveles en principiante, sin prisa. Lee el enunciado aunque aciertes a la primera.
- Al terminar, apunta en una línea qué hace cada propiedad de la tabla de arriba.
- Unos días después, vuelve en modo experto. Si te atascas en un nivel, ese es el tema que repasar.
- Lleva lo aprendido a algo real, como una barra de navegación con el logo a la izquierda y los enlaces a la derecha.
Esa barra son dos propiedades:
<nav>
<a class="logo" href="/">Logo</a>
<ul>
<li><a href="/blog/">Blog</a></li>
<li><a href="/sobre-mi/">Sobre mí</a></li>
<li><a href="/contacto/">Contacto</a></li>
</ul>
</nav>
nav {
display: flex;
justify-content: space-between; /* logo a un lado, enlaces al otro */
align-items: center; /* centrados en vertical */
}
nav ul {
display: flex; /* los enlaces, también en fila */
gap: 16px;
margin: 0;
padding: 0;
list-style: none;
}
En una barra de 500 × 60 px, con un logo de 80 × 40 px y tres enlaces de 56 × 20 px (la lista mide 200 px de ancho con los huecos), el logo queda en (0,10) y la lista en (300,20): cada uno en un extremo y los dos centrados en vertical.
Lo que conviene saber
- Enseña el contenedor, no todo Flexbox. No cubre
flex-grow,flex-shrinkniflex-basis, que deciden cuánto crece o encoge cada elemento, nigap, el hueco fijo entre elementos. Para eso está la guía de MDN. ordercambia lo que se ve, no el orden real. MDN advierte que quien navega con teclado o con lector de pantalla sigue el orden del HTML. Si el orden importa para entender la página, cámbialo en el HTML.- No sustituye a Grid. Flexbox reparte en una dimensión (una fila o una columna). Para cuadrículas de filas y columnas a la vez, mira CSS Grid Layout.
- Tu progreso se guarda en el navegador. Si cambias de equipo o borras los datos, empiezas de cero.
Quién lo hizo
Lo creó Thomas Park en 2015 y hoy forma parte de Codepip, su colección de juegos para aprender desarrollo web. El código está en GitHub con licencia MIT, y las imágenes, con licencia Creative Commons. La traducción al español es de Manuel González, uno de los más de 50 voluntarios que lo han traducido. El repositorio recibió cambios por última vez en enero de 2026.
Alternativas
- Grid Garden, del mismo autor y con el mismo estilo, para CSS Grid. Tienes más ideas en dónde practicar Grid en CSS.
- Conceptos básicos de Flexbox en MDN, en español: la referencia para lo que el juego no cubre.
- El juego de selectores CSS, CSS Diner, si quieres seguir aprendiendo CSS jugando.
- Learn CSS Layout the pedantic way, si quieres entender a fondo cómo coloca el navegador las cajas.
Fuentes
Comprobado el 9 de noviembre de 2026:
- Repositorio thomaspark/flexboxfroggy, que es el código que publica la web: autor, licencias y los 53 traductores (README), fecha del último cambio, las tres dificultades y los enlaces a Codepip (
index.html), el progreso guardado enlocalStorage(js/game.js) y los 24 niveles, sus propiedades y los valores que enseña cada uno (js/levels.js), que es con lo que se han contrastado las pistas. - MDN: conceptos básicos de Flexbox (ejes, valores iniciales,
flex-shrinkyflex-flow),justify-content(space-between,space-aroundyspace-evenly),align-content(sin efecto connowrap) yorder(valor inicial, empates y accesibilidad).
Todos los ejemplos CSS se han ejecutado en Google Chrome 157 sin interfaz (con puppeteer-core 25.16.0), con el montaje de 500 × 300 px descrito arriba. Las posiciones de los bloques de resultados son las medidas, redondeadas a una décima de píxel.