---
title: "Flutter Liquid Glass: packages, Impeller and approaches"
description: "Cupertino still has no official Liquid Glass. These Flutter Liquid Glass packages do: how each renders, where it needs Impeller, and which to pick."
url: https://liquidglassdesign.com/blog/flutter-liquid-glass-packages
language: en
published: 2026-11-18
updated: 2026-11-18
author: "Liquid Glass Design"
tags: ["Code"]
translations:
  zh-Hans: https://liquidglassdesign.com/zh/blog/flutter-liquid-glass-packages.md
  zh-Hant: https://liquidglassdesign.com/zh-TW/blog/flutter-liquid-glass-packages.md
  ja: https://liquidglassdesign.com/ja/blog/flutter-liquid-glass-packages.md
  hi: https://liquidglassdesign.com/hi/blog/flutter-liquid-glass-packages.md
---

# Flutter Liquid Glass: packages, Impeller and approaches

> Cupertino still has no official Liquid Glass. These Flutter Liquid Glass packages do: how each renders, where it needs Impeller, and which to pick.

Flutter has no official Liquid Glass yet. The Cupertino widgets haven't been updated, and the tracking issue is still open. To get the look today, either draw the glass with a package built on fragment shaders (`liquid_glass_widgets`, `liquid_glass_renderer`, `figma_glass`, `oc_liquid_glass`), or embed Apple's real controls through platform views on iOS (`cupertino_native`, `adaptive_platform_ui`).

Versions and download numbers are from pub.dev and GitHub on November 14, 2026.

## Is there official Cupertino support?

Flutter issue #170310, "Support for iOS 26 'Liquid Glass' Design in Cupertino Widgets", was opened in June 2025 and is still open, labeled P3, with more than 700 reactions. In June 2025 the Flutter team wrote that it was "not developing the new Apple'26 UI design features in the Cupertino library right now" and wouldn't accept contributions for them. In July 2025 it added that Material and Cupertino were being split into standalone packages, and that "all new work for iOS26 updates in Cupertino will happen in the new packages".

That split has happened. `cupertino_ui` is on pub.dev from the verified `flutter.dev` publisher, at version 1.1.6 (November 3, 2026). Its changelog so far is bug fixes and small additions, with no Liquid Glass entry. If official support arrives, it will most likely land in that package, so it's worth watching.

## Two ways to get the look

Drawing the glass in Flutter means a shader samples what's behind a widget, bends it at the rim, frosts and tints it. That works on every platform and inside any widget tree, and you set every parameter yourself. It's still an approximation of Apple's material, and you pay for it in GPU time.

Embedding native controls means hosting real `UITabBar`, `UIToolbar` or `UISwitch` views in your Flutter tree. On iOS 26 and later you get the exact system material, including the iOS 27 refinements and the user's transparency setting. The cost is that you only get the controls the package wraps, platform views have their own composition overhead, and you can't put arbitrary Flutter content inside the glass.

A useful test is Amine Kaddari's [Liquid Glass Music Player](https://liquidglassdesign.com/gallery/liquid-glass-music-player) in our gallery. A glass control panel floats over a grid of photos, the photos bend at the panel's rim with visible color fringing, and the playback buttons are small glass circles. That needs a shader package that samples the backdrop. A native `UIToolbar` wouldn't give you that custom panel.

![Clear glass player panel with play controls over a photo grid, the photos bending with rainbow fringes at its rim](https://cdn.liquidglassdesign.com/gallery/21ecd13d-8a84-8054-a147-ff0c529749e5.png)

*Liquid Glass Music Player by Amine Kaddari.* [See it in the gallery](https://liquidglassdesign.com/gallery/liquid-glass-music-player)
## Flutter Liquid Glass packages

### liquid_glass_widgets

Sebastian Degenaar's `liquid_glass_widgets` is the most complete widget set: `GlassScaffold`, `GlassAppBar`, `GlassTabBar`, `GlassSwitch`, `GlassSlider`, `GlassSegmentedControl`, menus, sheets and more, with `ios27` and `ios26` styles. It's at version 1.17.3 (November 13, 2026), MIT, needs Flutter 3.41 or newer, and has no dependencies beyond the Flutter SDK. On pub.dev it shows about 147,000 downloads in the last 30 days.

It picks a quality tier per platform. `GlassQuality.premium` does full refraction and chromatic dispersion on Impeller. `GlassQuality.standard` is a lighter single-pass shader used on Skia, the web and dense lists, and it doesn't refract arbitrary content behind the lens. `GlassQuality.minimal` is a plain `BackdropFilter` with no custom shader.

```dart
import 'package:flutter/cupertino.dart';
import 'package:liquid_glass_widgets/liquid_glass_widgets.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await LiquidGlassWidgets.initialize();
  runApp(LiquidGlassWidgets.wrap(child: const MyApp()));
}
```

If you use `MaterialApp`, the README says to pass `brightnessResolver: Theme.maybeBrightnessOf` to `wrap` so the glass follows your `ThemeMode`.

### liquid_glass_renderer

`liquid_glass_renderer` from whynotmake.it is the lower-level option: shapes, layers and blend groups. You build your own controls on top. Version 1.0 is a full rewrite with iOS 27 presets, and every published version so far, including the 0.2.x line, is a dev pre-release.

- Full glass needs Impeller plus the Flutter GPU API, which the README describes as "still in preview". You turn it on with `--enable-flutter-gpu`, or with `FLTEnableFlutterGPU` in `Info.plist` and an `EnableFlutterGPU` meta-data entry in `AndroidManifest.xml`.
- Where full glass isn't available (Skia, the web, Flutter GPU off), layers switch to `FakeGlass`, which keeps frost, tint and the rim glint but drops refraction.
- It's tested on iOS, Android and macOS, and licensed Apache 2.0.

Check the SDK constraint before you add it. `1.0.0-dev.2` declares Flutter 3.47 or newer but Dart `>=3.13.0 <3.14.0`. Flutter 3.50.0, the stable release from November 11, 2026, ships Dart 3.14.0, so on current stable the dev release won't resolve until the package widens that range.

```dart
Stack(
  children: [
    const Positioned.fill(child: MyContent()),
    Center(
      child: LiquidGlassLayer(
        settings: LiquidGlassSettings.ios27Regular(brightness: brightness),
        child: const LiquidGlass(
          shape: LiquidRoundedSuperellipse(borderRadius: 28),
          child: SizedBox(width: 220, height: 56),
        ),
      ),
    ),
  ],
)
```

Glass samples the pixels behind it, so the content and the glass go in the same `Stack`. `LiquidGlassBlendGroup` merges nearby shapes, much like SwiftUI's `GlassEffectContainer`, which our [SwiftUI Liquid Glass guide](https://liquidglassdesign.com/blog/swiftui-liquid-glass) covers.

### figma_glass

Parth Bhensdadiya's `figma_glass` maps Figma's Glass panel one to one: light angle, light, refraction, depth, dispersion, frost and splay are fields with the same names and ranges. If your designers tune glass in Figma (the [Glass effect playground](https://liquidglassdesign.com/resources/glass-effect-playground) is a good place to learn those controls), you can copy their numbers across. It renders the backdrop you pass to `GlassBackground` into a snapshot and refracts that with a fragment shader. The author tested it on Android with Impeller on Vulkan, the iOS simulator and Chrome. It's new and small: version 0.1.3 (October 2026), MIT, Flutter 3.44 or newer.

### oc_liquid_glass

`oc_liquid_glass` draws glass droplets with GPU fragment shaders. It works only on Impeller platforms (Android, iOS and macOS on its pub.dev page), groups at most four shapes, and was last released in June 2026 (0.3.0).

### Native controls: cupertino_native and adaptive_platform_ui

`cupertino_native` from Serverpod hosts real UIKit and AppKit controls through platform views: slider, switch, segmented control, button, SF Symbol icon, popup menu and tab bar. Its README calls it a proof of concept, and the last release (0.1.1) dates from September 2025.

`adaptive_platform_ui` is more active (1.0.2, October 2026, MIT). It renders native iOS 26 `UIToolbar`, `UITabBar` and `UIButton` on iOS 26 and later, classic Cupertino widgets on older iOS, and Material on Android.

### The early experiment on our resources page

The [Flutter liquid glass](https://liquidglassdesign.com/resources/flutter-liquid-glass) entry in our resources links Colby Maloy's repository, an "attempt at implementing liquid glass specifications in flutter" from June 2025. It's worth reading as a small shader example, but it hasn't been updated since June 2025 and GitHub detects no license, so don't ship it as a dependency.

## Impeller, Android and the web

The packages that refract the live backdrop depend on Impeller, so check where your app runs on it. Per Flutter's Impeller docs, Impeller is the only renderer on iOS. On Android it's the default on API 29 and newer with Vulkan, and other devices fall back to the legacy OpenGL renderer. macOS, Windows and Linux have it on by default since Flutter 3.47. The web still uses Skia.

In practice:

- Test on an Android device without Vulkan, or on API 28 or older, to see your fallback tier. `liquid_glass_widgets` ships a separate GLES shader for that case.
- On the web, `liquid_glass_renderer` falls back to `FakeGlass` and `liquid_glass_widgets` to its lighter shader. `figma_glass` does refract on the web, because it works from a snapshot of the background you hand it. If the web matters, our [web performance and fallback guide](https://liquidglassdesign.com/blog/liquid-glass-web-performance-fallbacks) applies to Flutter web too.
- Load shaders before the first glass appears, with `LiquidGlass.precache()` or `LiquidGlassWidgets.initialize()`. The renderer's README notes that otherwise the first glass paints `FakeGlass` for a frame or two.

## Performance rules from the renderer docs

The `liquid_glass_renderer` README sums up the cost model: "The unit of cost is the backdrop copy, not the glass widget." On Impeller, each independent `BackdropFilter` copies the render pass behind it, usually the whole screen. Most of its advice carries over to any package built on `BackdropFilter`:

- Put sibling shapes in one layer, so a tab bar with five glass buttons is one backdrop copy.
- Keep layers small. Cost grows with the area the glass covers.
- Don't animate blend-group geometry every frame. Moving one shape re-renders the group.
- Keep shadows few and small.
- Very small blurs aren't always cheaper. Impeller only starts downsampling above roughly 5.8 device pixels.

MAni Ghafouri's [Liquid Glass Camera Toolbar](https://liquidglassdesign.com/gallery/liquid-glass-camera-toolbar) is a good layout under these rules: a round thumbnail, a pill segmented control with the selected "Cinematic" lens inside it, and a round flip button. Put all three in one layer and the toolbar costs one backdrop copy.

![Camera toolbar with a round selfie thumbnail, a clear pill control showing Cinematic in yellow, and a round flip button](https://cdn.liquidglassdesign.com/gallery/296cd13d-8a84-8065-9b1d-f50b8d9fb531.jpg)

*Liquid Glass Camera Toolbar by MAni Ghafouri.* [See it in the gallery](https://liquidglassdesign.com/gallery/liquid-glass-camera-toolbar)
## Which one to use

1. You want ready-made iOS 27-style controls on every platform: `liquid_glass_widgets`.
2. You're building a custom glass design system and can live with a pre-release: `liquid_glass_renderer`, once its Dart constraint matches your SDK.
3. Your designers specify glass in Figma and you want their numbers to carry over: `figma_glass`.
4. The app is iOS-first and you want the exact system bars, including iOS 27 behavior and the user's transparency setting: `adaptive_platform_ui` for bars and buttons, with Flutter content everywhere else.

Whichever you pick, plan the accessibility fallback yourself. Flutter's `AccessibilityFeatures` has `highContrast`, `reduceMotion` and `disableAnimations` but no Reduce Transparency flag, so the framework gives you no way to read that iOS setting. `liquid_glass_widgets` maps Increase Contrast (`MediaQuery.highContrastOf`) to its reduced-transparency mode and offers `GlassAccessibilityScope(reduceTransparency: true)` for a manual switch. With the other packages, wire a solid style to `highContrast` and to an in-app setting. Native platform-view controls are the exception: they follow the system settings on their own.

For background on the material itself, see our [explainer on what Liquid Glass is](https://liquidglassdesign.com/what-is-liquid-glass).

*Versions, settings and figures checked on 14 November 2026.*

## Sources

- https://github.com/flutter/flutter/issues/170310
- https://github.com/flutter/flutter/issues/101479
- https://pub.dev/packages/cupertino_ui
- https://github.com/flutter/packages/blob/main/packages/cupertino_ui/CHANGELOG.md
- https://pub.dev/packages/liquid_glass_widgets
- https://github.com/sdegenaar/liquid_glass_widgets
- https://pub.dev/packages/liquid_glass_renderer
- https://github.com/whynotmake-it/flutter_liquid_glass/tree/main/packages/liquid_glass_renderer
- https://pub.dev/packages/figma_glass
- https://github.com/parthbhensdadiya226/figma_glass
- https://pub.dev/packages/oc_liquid_glass
- https://pub.dev/packages/cupertino_native
- https://pub.dev/packages/adaptive_platform_ui
- https://github.com/colbymaloy/flutter_liquid_glass
- https://docs.flutter.dev/perf/impeller
- https://api.flutter.dev/flutter/dart-ui/AccessibilityFeatures-class.html
- https://docs.flutter.dev/release/archive
