Mobile10 min de leitura
Liquid Glass no React Native com expo-glass-effect
Como usar o Liquid Glass do iOS 26 no React Native com expo-glass-effect: GlassView, GlassContainer, fallback pro Android, tint, chip que se funde e uma demo.

O iOS 26 trouxe o Liquid Glass: barras, botões e cartões que parecem vidro de verdade, refletindo e distorcendo o que passa por baixo. No React Native, dá pra usar o material do próprio sistema com o expo-glass-effect, sem imitar com blur e transparência.
Eu coloquei esse vidro na barra de abas de um app meu, e a parte fácil foi a primeira linha de código. A difícil foi todo o resto: aparelho sem suporte, chip que não se fundia, vidro que sumia sobre fundo claro e rótulo ilegível no modo escuro.
Pra este post, montei um app de demo com quatro componentes novos (cartão, botão, segmented control e barra de abas) e rodei no simulador do iPhone 17 Pro com iOS 26.5. Todo o código está aqui.
O projeto completo, pronto pra rodar, está no GitHub: yasminlopes/react-native-liquid-glass.
TL;DR#
GlassViewsó existe no iOS 26 pra cima. No Android e em iPhone desatualizado ele vira umaViewcomum, então desenhe o fallback de propósito.- Carregue o módulo com
requireprotegido e decida tudo numa chave só (hasGlass), comisGlassEffectAPIAvailable()eisLiquidGlassAvailable(). - Nada de
backgroundColorno vidro. Quem dá corpo à peça é o material; uma cor por cima apaga o efeito. regularpra superfície,clearpra vidro sobre vidro. Sobre fundo claro, usetintColor, senão o vidro parece um painel branco.- A prop é
colorScheme, nãoglassColorScheme. Prop errada em React não dá erro: some. - Pra duas peças se fundirem dentro do
GlassContainer, mova porleft, não portransform. A fusão é calculada pela posição de layout. - Não anime
opacityno vidro. Troque oglassEffectStyle, que tem animação nativa.
O que é o expo-glass-effect#
O expo-glass-effect expõe o UIVisualEffectView do iOS com o material de vidro. São dois componentes e duas funções:
GlassView: umaViewcom o material de vidro. AceitaglassEffectStyle('regular','clear'ou'none'),tintColor,isInteractiveecolorScheme.GlassContainer: agrupa váriasGlassViewpra que elas se fundam quando chegam perto, como as gotas de mercúrio dos controles da Apple. A propspacingdefine a distância em que a fusão começa.isLiquidGlassAvailable(): diz se o app foi compilado com suporte e se o sistema tem o material.isGlassEffectAPIAvailable(): confere se a API existe de verdade no aparelho. Ela foi criada porque algumas betas do iOS 26 não tinham a API e o app quebrava.
A instalação é a de sempre:
npx expo install expo-glass-effectÉ um módulo nativo, então ele precisa estar na build do app. Eu rodei a demo num development build (expo-dev-client), compilado direto pro simulador.
1. Carregue o módulo com rede de segurança#
A primeira tentação é um import { GlassView } from 'expo-glass-effect' no topo do arquivo. Funciona, até alguém abrir o app numa build que ainda não tem a parte nativa do módulo, como um development build feito antes de você instalar o pacote. Aí o import quebra, e não é o componente que cai: é toda tela que importa ele. No meu caso, era a barra de abas, presente em todas as telas.
Dependência nativa que é opcional entra por um 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. Uma chave só pra tudo#
O vidro mexe em várias coisas ao mesmo tempo: o material, a cor do texto em cima dele, o jeito de animar o chip. Se cada componente checar o suporte do seu jeito, mais cedo ou mais tarde aparece uma combinação que ninguém desenhou, como chip transparente com texto branco por cima.
Por isso, uma chave só:
/** 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);A decisão acontece em tempo de execução, não na build: o mesmo app roda num iPhone com iOS 26 e num Android, e cada um cai no seu estado.
O EXPO_PUBLIC_FORCE_FALLBACK é um atalho de desenvolvimento: com ele, dá pra ver no próprio simulador o que quem não tem vidro vai ver.
3. Nada de cor de fundo no vidro#
O cartão é o componente mais simples, e já tem uma armadilha: se você passar backgroundColor pro GlassView, a cor fica por cima do material e o vidro some. Com vidro, quem dá corpo à peça é o sistema. Sem vidro, aí sim, entra o fundo branco com 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 },
},
});Repare que as props de vidro só vão quando hasGlass é verdadeiro. Numa View comum, glassEffectStyle não faz nada, mas deixar tudo condicional mantém o fallback limpo e fácil de ler.
4. regular, clear e o tint#
O glassEffectStyle tem dois materiais:
regular: o vidro mais denso, pra superfícies com texto em cima (barra, cartão).clear: mais transparente, pra peças pequenas ou pra vidro sobre vidro. Dois vidros densos empilhados viram um borrão.
E aqui veio a primeira surpresa no app real: sobre um fundo quase branco, o vidro regular fica idêntico a um painel branco. O material existe, mas não aparece, porque não tem nada colorido por baixo pra ele refletir. A solução é o tintColor, uma cor da marca com alfa baixo:
<GlassSurface
style={[styles.bar, hasGlass ? null : styles.solidBar]}
{...(hasGlass
? { glassEffectStyle: 'regular', colorScheme: 'light', tintColor: 'rgba(255, 56, 92, 0.05)' }
: {})}
>Forte o bastante pro material aparecer, fraco o bastante pros rótulos continuarem legíveis.
No modo escuro, o tint vira o corpo da peça#
No app, o modo escuro trouxe a segunda surpresa. O vidro regular com o tint fraco continuava claro sobre a tela quase preta: a barra virava uma pastilha esbranquiçada, e os rótulos cinza das abas inativas sumiam dentro dela.
Dois ajustes resolveram:
colorSchemecom o tema do app ('light'ou'dark'), pra o material seguir o seu tema e não o do sistema. E atenção: no começo eu escreviglassColorScheme, que não existe. Prop desconhecida em React não dá erro nem aviso, só é ignorada, e o vidro continuou seguindo o sistema até eu reler a documentação.- No escuro, um tint escuro com alfa alto. Ele empurra o material pra baixo e devolve o contraste dos rótulos. No claro, o mesmo alfa alto deixaria a barra chapada de cor, então os dois temas têm valores diferentes.
E o contraste dos rótulos precisa ser medido sobre o vidro, não sobre o fundo da tela. O cinza que passava com folga sobre o fundo escuro caía pra uns 3:1 sobre a barra tingida, e eu tive que clarear o rótulo inativo só quando tem vidro.
5. O chip que se funde#
O componente mais bonito, e o que deu mais trabalho: um segmented control em que o chip do item selecionado desliza e se funde com a barra, como o controle nativo do iOS.
A estrutura é um GlassGroup (o GlassContainer) com a barra de vidro dentro e o chip, também de vidro, dentro da barra. O chip usa clear, porque é vidro sobre vidro.
No app, a primeira versão animava o chip com transform: translateX, o jeito mais barato de mover alguma coisa. O chip deslizava, mas as duas peças nunca se fundiam.
O motivo: a fusão do GlassContainer é calculada pelo sistema a partir da posição de layout de cada peça. O transform move o que aparece na tela, mas não mexe no frame; pro iOS, o chip continuava parado no canto. Duas peças que nunca se aproximam nunca se fundem.
A solução é mover o chip por left, que é layout. Como animar layout no Animated do React Native roda na thread de JavaScript (e engasga bem quando a tela troca), eu uso o 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>
);
}Mais dois detalhes que valem pra qualquer componente com vidro:
- A cor do texto do item ativo depende de
hasGlass. Sem vidro, o chip é vermelho sólido e o texto é branco. Com vidro, o chip é transparente, e texto branco sumiria justamente na aba selecionada. useReducedMotionrespeita quem desligou animações no sistema: o chip pula pro lugar em vez de deslizar.
6. Botão interativo#
O isInteractive faz o próprio sistema reagir ao toque: o vidro brilha e estica um pouco quando o dedo encosta, sem nenhuma linha de animação sua.
<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>Não anime a opacidade do vidro#
A Apple não recomenda opacity abaixo de 1 no vidro nem nos pais dele: com opacidade baixa, o efeito simplesmente não renderiza. Pra aparecer e sumir, o glassEffectStyle aceita um objeto com animação nativa:
<GlassView
glassEffectStyle={{ style: visible ? 'regular' : 'none', animate: true, animationDuration: 0.5 }}
/>A barra de abas: forma é layout, material é sistema#
Um último aprendizado, mais de produto que de código. A barra de abas flutuante, com o chip que desliza, tem duas partes:
- a forma (uma pílula flutuando acima do conteúdo, separada da borda), que é layout e funciona em qualquer aparelho;
- o material (vidro), que só existe no iOS 26.
Separar as duas coisas foi o que deixou a decisão fácil: todo mundo ganhou a barra nova, e quem tem iOS 26 ganhou também o vidro. Ninguém ficou com uma barra quebrada por falta de suporte.
Checklist#
npx expo install expo-glass-effecte uma build nova do app.- Módulo carregado com
requireprotegido. - Uma chave só (
hasGlass) com as duas checagens, e um jeito de forçar o fallback no simulador. - Nada de
backgroundColornoGlassView. regularpra superfície,clearpra vidro sobre vidro,tintColorsobre fundo claro.colorSchemeseguindo o tema do app, e tint mais forte no escuro.- Contraste dos textos medido sobre o vidro.
- Peças que se fundem dentro de um
GlassContainer, movidas porleft. - Nada de
opacityno vidro; use oglassEffectStyleanimado. - Print com vidro e sem vidro antes de dizer que está pronto.
Referências#
Leia também

Mobile9 min de leitura
Expo SDK 58: o que quebrou ao atualizar meu app

Mobile10 min de leitura
O iPad também é celular: o que quebra no tablet

Back-end13 min de leitura
App feito com IA: o que conferir antes de publicar