Mobile11 min de lectura
Liquid Glass en React Native con expo-glass-effect
Cómo usar el Liquid Glass de iOS 26 en React Native con expo-glass-effect: GlassView, GlassContainer, fallback en Android, tint, chip que se funde y cuatro componentes.

iOS 26 trajo el Liquid Glass: barras, botones y tarjetas que parecen vidrio de verdad, reflejando y deformando lo que pasa por debajo. En React Native puedes usar el material del propio sistema con expo-glass-effect, sin imitarlo con blur y transparencia.
Puse este vidrio en la barra de pestañas de una app mía, y la parte fácil fue la primera línea de código. La difícil fue todo lo demás: dispositivos sin soporte, un chip que no se fundía, vidrio que desaparecía sobre fondo claro y etiquetas ilegibles en modo oscuro.
Para este post armé una app de demo con cuatro componentes nuevos (tarjeta, botón, segmented control y barra de pestañas) y la corrí en el simulador del iPhone 17 Pro con iOS 26.5. Todo el código está aquí.
El proyecto completo, listo para correr, está en GitHub: yasminlopes/react-native-liquid-glass.
TL;DR#
GlassViewsolo existe de iOS 26 en adelante. En Android y en iPhones desactualizados se convierte en unaViewcomún, así que diseña el fallback a propósito.- Carga el módulo con un
requireprotegido y decide todo con un solo interruptor (hasGlass), usandoisGlassEffectAPIAvailable()yisLiquidGlassAvailable(). - Nada de
backgroundColoren el vidrio. El material es lo que le da cuerpo a la pieza; un color encima borra el efecto. regularpara superficies,clearpara vidrio sobre vidrio. Sobre fondo claro, usatintColor, si no el vidrio parece un panel blanco.- La prop es
colorScheme, noglassColorScheme. Una prop equivocada en React no da error: desaparece. - Para que dos piezas se fundan dentro del
GlassContainer, muévelas conleft, no contransform. La fusión se calcula por la posición de layout. - No animes
opacityen el vidrio. Cambia elglassEffectStyle, que tiene animación nativa.
Qué es expo-glass-effect#
expo-glass-effect expone el UIVisualEffectView de iOS con el material de vidrio. Son dos componentes y dos funciones:
GlassView: unaViewcon el material de vidrio. AceptaglassEffectStyle('regular','clear'o'none'),tintColor,isInteractiveycolorScheme.GlassContainer: agrupa variasGlassViewpara que se fundan cuando se acercan, como las gotas de mercurio de los controles de Apple. La propspacingdefine la distancia a la que empieza la fusión.isLiquidGlassAvailable(): dice si la app se compiló con soporte y si el sistema tiene el material.isGlassEffectAPIAvailable(): comprueba si la API existe de verdad en el dispositivo. Se creó porque algunas betas de iOS 26 no tenían la API y la app se rompía.
La instalación es la de siempre:
npx expo install expo-glass-effectEs un módulo nativo, así que tiene que estar en la build de la app. Corrí la demo en un development build (expo-dev-client), compilado directo para el simulador.
1. Carga el módulo con red de seguridad#
La primera tentación es un import { GlassView } from 'expo-glass-effect' arriba del archivo. Funciona, hasta que alguien abre la app en una build que todavía no tiene la parte nativa del módulo, como un development build hecho antes de instalar el paquete. Ahí el import se rompe, y no se cae el componente: se cae toda pantalla que lo importa. En mi caso era la barra de pestañas, presente en todas las pantallas.
Una dependencia nativa que es opcional entra por un require protegido:
import type { ComponentType } from 'react';
import { View, type ViewProps } from 'react-native';
type GlassModule = typeof import('expo-glass-effect');
function load(): GlassModule | null {
try {
return require('expo-glass-effect') as GlassModule;
} catch {
return null;
}
}
const glass = load();2. Un solo interruptor para todo#
El vidrio toca varias cosas a la vez: el material, el color del texto encima, la forma de animar el chip. Si cada componente comprueba el soporte a su manera, tarde o temprano aparece una combinación que nadie diseñó, como un chip transparente con texto blanco encima.
Por eso, un solo interruptor:
/** Set EXPO_PUBLIC_FORCE_FALLBACK=1 to see what Android and iOS < 26 users get. */
const forceFallback = process.env.EXPO_PUBLIC_FORCE_FALLBACK === '1';
export const hasGlass: boolean = (() => {
if (forceFallback || !glass) return false;
try {
return glass.isGlassEffectAPIAvailable() && glass.isLiquidGlassAvailable();
} catch {
return false;
}
})();
type AnyView = ComponentType<ViewProps & Record<string, unknown>>;
/** The system glass when available, a plain View otherwise. */
export const GlassSurface: AnyView = hasGlass && glass ? (glass.GlassView as AnyView) : (View as AnyView);
/** Groups glass pieces so they merge when they get close. A plain View otherwise. */
export const GlassGroup: AnyView = hasGlass && glass ? (glass.GlassContainer as AnyView) : (View as AnyView);La decisión pasa en tiempo de ejecución, no en la build: la misma app corre en un iPhone con iOS 26 y en un Android, y cada uno cae en su estado.
EXPO_PUBLIC_FORCE_FALLBACK es un atajo de desarrollo: con él puedes ver en el propio simulador lo que verá quien no tiene vidrio.
3. Nada de color de fondo en el vidrio#
La tarjeta es el componente más simple, y ya tiene una trampa: si le pasas backgroundColor al GlassView, el color queda encima del material y el vidrio desaparece. Con vidrio, el que le da cuerpo a la pieza es el sistema. Sin vidrio, ahí sí entra el fondo blanco con sombra:
export function GlassCard({ children, style }: { children: ReactNode; style?: StyleProp<ViewStyle> }) {
return (
<GlassSurface
style={[styles.card, hasGlass ? null : styles.solid, style]}
{...(hasGlass ? { glassEffectStyle: 'regular', colorScheme: 'light' } : {})}
>
{children}
</GlassSurface>
);
}
const styles = StyleSheet.create({
card: { borderRadius: 28, padding: 20, overflow: 'hidden' },
solid: {
backgroundColor: '#ffffff',
borderWidth: 1,
borderColor: 'rgba(20, 20, 20, 0.08)',
shadowColor: '#000',
shadowOpacity: 0.12,
shadowRadius: 24,
shadowOffset: { width: 0, height: 12 },
},
});Fíjate en que las props de vidrio solo se pasan cuando hasGlass es verdadero. En una View común, glassEffectStyle no hace nada, pero dejarlo todo condicional mantiene el fallback limpio y fácil de leer.
4. regular, clear y el tint#
glassEffectStyle tiene dos materiales:
regular: el vidrio más denso, para superficies con texto encima (barra, tarjeta).clear: más transparente, para piezas pequeñas o para vidrio sobre vidrio. Dos vidrios densos apilados se vuelven un borrón.
Y aquí llegó la primera sorpresa en la app real: sobre un fondo casi blanco, el vidrio regular queda idéntico a un panel blanco. El material existe, pero no se ve, porque no hay nada de color debajo para reflejar. La solución es tintColor, un color de la marca con alfa bajo:
<GlassSurface
style={[styles.bar, hasGlass ? null : styles.solidBar]}
{...(hasGlass
? { glassEffectStyle: 'regular', colorScheme: 'light', tintColor: 'rgba(255, 56, 92, 0.05)' }
: {})}
>Lo bastante fuerte para que el material se vea, lo bastante suave para que las etiquetas sigan legibles.
En modo oscuro, el tint se convierte en el cuerpo de la pieza#
En la app, el modo oscuro trajo la segunda sorpresa. El vidrio regular con el tint suave seguía claro sobre la pantalla casi negra: la barra se volvía una pastilla blanquecina, y las etiquetas grises de las pestañas inactivas desaparecían dentro de ella.
Dos ajustes lo resolvieron:
colorSchemecon el tema de la app ('light'o'dark'), para que el material siga tu tema y no el del sistema. Y ojo: al principio escribíglassColorScheme, que no existe. Una prop desconocida en React no da error ni aviso, solo se ignora, y el vidrio siguió al sistema hasta que releí la documentación.- En oscuro, un tint oscuro con alfa alto. Empuja el material hacia abajo y devuelve el contraste de las etiquetas. En claro, el mismo alfa alto dejaría la barra plana de color, así que los dos temas tienen valores distintos.
Y el contraste de las etiquetas hay que medirlo sobre el vidrio, no sobre el fondo de la pantalla. El gris que pasaba de sobra sobre el fondo oscuro caía a unos 3:1 sobre la barra teñida, y tuve que aclarar la etiqueta inactiva solo cuando hay vidrio.
5. El chip que se funde#
El componente más bonito, y el que más trabajo dio: un segmented control en el que el chip del ítem seleccionado se desliza y se funde con la barra, como el control nativo de iOS.
La estructura es un GlassGroup (el GlassContainer) con la barra de vidrio dentro y el chip, también de vidrio, dentro de la barra. El chip usa clear, porque es vidrio sobre vidrio.
En la app, la primera versión animaba el chip con transform: translateX, la forma más barata de mover algo. El chip se deslizaba, pero las dos piezas nunca se fundían.
El motivo: la fusión del GlassContainer la calcula el sistema a partir de la posición de layout de cada pieza. El transform mueve lo que aparece en pantalla, pero no toca el frame; para iOS, el chip seguía quieto en la esquina. Dos piezas que nunca se acercan nunca se funden.
La solución es mover el chip con left, que es layout. Como animar layout con el Animated de React Native corre en el hilo de JavaScript (y se traba bastante cuando cambia la pantalla), uso Reanimated:
const PAD = 4;
export function GlassSegmented({ options, value, onChange }: { options: string[]; value: number; onChange: (index: number) => void }) {
const [width, setWidth] = useState(0);
const slot = width > 0 ? (width - PAD * 2) / options.length : 0;
const reduceMotion = useReducedMotion();
const position = useSharedValue(value);
useEffect(() => {
position.value = reduceMotion ? value : withSpring(value, { damping: 18, stiffness: 180, mass: 0.9 });
}, [value, reduceMotion, position]);
// With glass the chip moves by `left` (layout), so the system can merge it with the track.
// Without glass, `transform` is cheaper and there is nothing to merge.
const chipStyle = useAnimatedStyle(() =>
hasGlass
? { width: slot, left: PAD + position.value * slot }
: { width: slot, left: PAD, transform: [{ translateX: position.value * slot }] },
);
return (
<GlassGroup style={styles.group} {...(hasGlass ? { spacing: 16 } : {})}>
<GlassSurface
onLayout={(e) => setWidth(e.nativeEvent.layout.width)}
style={[styles.track, hasGlass ? null : styles.solidTrack]}
{...(hasGlass ? { glassEffectStyle: 'regular', colorScheme: 'light' } : {})}
>
{slot > 0 && (
<Animated.View pointerEvents="none" style={[styles.chip, chipStyle]}>
{hasGlass ? (
<GlassSurface style={styles.chipFill} glassEffectStyle="clear" colorScheme="light" isInteractive />
) : (
<View style={[styles.chipFill, styles.solidChip]} />
)}
</Animated.View>
)}
{options.map((label, index) => (
<Pressable key={label} style={styles.option} onPress={() => onChange(index)} accessibilityRole="tab">
<Text
style={[
styles.label,
// White only works on the solid chip. On glass the chip is see-through.
{ color: index === value ? (hasGlass ? '#141414' : '#ffffff') : '#5c5c66' },
]}
>
{label}
</Text>
</Pressable>
))}
</GlassSurface>
</GlassGroup>
);
}Dos detalles más que valen para cualquier componente con vidrio:
- El color del texto del ítem activo depende de
hasGlass. Sin vidrio, el chip es rojo sólido y el texto es blanco. Con vidrio, el chip es transparente, y un texto blanco desaparecería justo en la pestaña seleccionada. useReducedMotionrespeta a quien desactivó las animaciones en el sistema: el chip salta a su lugar en vez de deslizarse.
6. Botón interactivo#
isInteractive hace que el propio sistema reaccione al toque: el vidrio brilla y se estira un poco cuando el dedo lo toca, sin una sola línea de animación tuya.
<Pressable onPress={onPress} accessibilityRole="button">
<GlassSurface
style={[styles.button, hasGlass ? null : styles.solid]}
{...(hasGlass ? { glassEffectStyle: 'regular', isInteractive: true, tintColor: 'rgba(255, 56, 92, 0.35)' } : {})}
>
<Text style={[styles.label, { color: hasGlass ? '#141414' : '#ffffff' }]}>{label}</Text>
</GlassSurface>
</Pressable>No animes la opacidad del vidrio#
Apple no recomienda opacity por debajo de 1 en el vidrio ni en sus padres: con opacidad baja, el efecto simplemente no se renderiza. Para aparecer y desaparecer, glassEffectStyle acepta un objeto con animación nativa:
<GlassView
glassEffectStyle={{ style: visible ? 'regular' : 'none', animate: true, animationDuration: 0.5 }}
/>La barra de pestañas: la forma es layout, el material es sistema#
Un último aprendizaje, más de producto que de código. La barra de pestañas flotante, con el chip que se desliza, tiene dos partes:
- la forma (una píldora flotando sobre el contenido, separada del borde), que es layout y funciona en cualquier dispositivo;
- el material (vidrio), que solo existe en iOS 26.
Separar las dos cosas fue lo que hizo fácil la decisión: todo el mundo recibió la barra nueva, y quien tiene iOS 26 recibió también el vidrio. Nadie se quedó con una barra rota por falta de soporte.
Checklist#
npx expo install expo-glass-effecty una build nueva de la app.- Módulo cargado con un
requireprotegido. - Un solo interruptor (
hasGlass) con las dos comprobaciones, y una forma de forzar el fallback en el simulador. - Nada de
backgroundColoren elGlassView. regularpara superficies,clearpara vidrio sobre vidrio,tintColorsobre fondo claro.colorSchemesiguiendo el tema de la app, y un tint más fuerte en oscuro.- Contraste de los textos medido sobre el vidrio.
- Piezas que se funden dentro de un
GlassContainer, movidas conleft. - Nada de
opacityen el vidrio; usa elglassEffectStyleanimado. - Captura con vidrio y sin vidrio antes de decir que está listo.
Referencias#
Sigue leyendo

Mobile9 min de lectura
Actualizar a Expo SDK 58: qué se rompió en React Native

Mobile11 min de lectura
El iPad también es celular: lo que se rompe en la tablet

Back-end14 min de lectura
App hecha con IA: qué revisar antes de publicarla