Todos os artigos

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.

Também em English, Español, Français

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#

  • GlassView só existe no iOS 26 pra cima. No Android e em iPhone desatualizado ele vira uma View comum, então desenhe o fallback de propósito.
  • Carregue o módulo com require protegido e decida tudo numa chave só (hasGlass), com isGlassEffectAPIAvailable() e isLiquidGlassAvailable().
  • Nada de backgroundColor no vidro. Quem dá corpo à peça é o material; uma cor por cima apaga o efeito.
  • regular pra superfície, clear pra vidro sobre vidro. Sobre fundo claro, use tintColor, senão o vidro parece um painel branco.
  • A prop é colorScheme, não glassColorScheme. Prop errada em React não dá erro: some.
  • Pra duas peças se fundirem dentro do GlassContainer, mova por left, não por transform. A fusão é calculada pela posição de layout.
  • Não anime opacity no vidro. Troque o glassEffectStyle, 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: uma View com o material de vidro. Aceita glassEffectStyle ('regular', 'clear' ou 'none'), tintColor, isInteractive e colorScheme.
  • GlassContainer: agrupa várias GlassView pra que elas se fundam quando chegam perto, como as gotas de mercúrio dos controles da Apple. A prop spacing define 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.

A demo no iOS 26.5: cartões, segmented control, botão e barra de abas em vidro

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:

glass.ts
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ó:

glass.ts
/** 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.

O mesmo código sem vidro: superfícies sólidas, desenhadas de propósito

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:

GlassCard.tsx
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:

GlassTabBar.tsx
<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:

  • colorScheme com 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 escrevi glassColorScheme, 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:

GlassSegmented.tsx
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.
  • useReducedMotion respeita 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.

GlassButton.tsx
<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-effect e uma build nova do app.
  • Módulo carregado com require protegido.
  • Uma chave só (hasGlass) com as duas checagens, e um jeito de forçar o fallback no simulador.
  • Nada de backgroundColor no GlassView.
  • regular pra superfície, clear pra vidro sobre vidro, tintColor sobre fundo claro.
  • colorScheme seguindo 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 por left.
  • Nada de opacity no vidro; use o glassEffectStyle animado.
  • Print com vidro e sem vidro antes de dizer que está pronto.

Referências#

  • Mobile
  • react-native
  • expo
  • ios
  • liquid glass
  • reanimated

Escrito por

Engenheira de software e designer. Escrevo sobre o que encontro construindo apps, APIs e produtos.