Communitygithub.com

Liquid Glass Design System (iOS 26)

iOS 26 Liquid Glass Design-System – dynamisches Glasmaterial mit Unschärfe, Spiegelung und interaktivem Morphen für SwiftUI, UIKit und WidgetKit. Verwenden Sie es, wenn Sie iOS 26 Liquid Glass UI in SwiftUI, UIKit oder WidgetKit erstellen.

Was ist Liquid Glass Design System (iOS 26)?

Dieses Skill implementiert das Liquid-Glass-Designsystem von Apple für iOS 26, ein dynamisches Material, das den dahinterliegenden Inhalt unscharf macht, Farbe und Licht der Umgebung reflektiert und auf Berührungs- und Zeigerinteraktionen reagiert. Es deckt die Integration in SwiftUI, UIKit und WidgetKit ab und bietet einen einfachen `.glassEffect()`-Modifikator für SwiftUI, `UIGlassEffect` für UIKit und spezifische APIs für Widgets. Zu den Hauptmerkmalen gehören anpassbare Formen (Kapsel, Rechteck, Kreis), interaktive Zustände (`interactive()`), Container (`GlassEffectContainer`) für mehrere Glaselemente, um ein Morphen zu ermöglichen, sowie Union- und Morphing-Übergänge. Für Widgets werden der `widgetRenderingMode` und akzentuierte Darstellungsmodi unterstützt, um sich nahtlos in das Betriebssystem einzufügen. Das Skill betont Best Practices wie die Verwendung von Containern für die Leistung, das Vermeiden übermäßiger Glaseffekte und die Sicherstellung der Barrierefreiheit. Es eignet sich für Navigationsleisten, Toolbars, schwebende Aktionsbuttons und interaktive Steuerelemente sowie für Widgets, die mit dem Liquid-Glass-Stil von iOS 26 harmonieren sollen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/everything-claude-code/tree/main/skills/liquid-glass-design

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Liquid Glass Design System (iOS 26)?

Muster zur Implementierung von Apples Liquid Glass – einem dynamischen Material, das den dahinterliegenden Inhalt unscharf macht, Farbe und Licht der Umgebung reflektiert und auf Berührungs- und Zeigerinteraktionen reagiert. Deckt die Integration in SwiftUI, UIKit und WidgetKit ab.

Wann aktivieren

  • Entwickeln oder Aktualisieren von Apps für iOS 26+ mit der neuen Designsprache
  • Implementieren von Glasstilen für Buttons, Karten, Symbolleisten oder Container
  • Erstellen von morphierenden Übergängen zwischen Glaselementen
  • Anwenden von Liquid Glass-Effekten auf Widgets
  • Migrieren bestehender Unschärfe-/Materialeffekte zur neuen Liquid Glass API

Kernmuster – SwiftUI

Grundlegender Glaseffekt

Der einfachste Weg, Liquid Glass zu einer beliebigen Ansicht hinzuzufügen:

Text("Hallo, Welt!")
    .font(.title)
    .padding()
    .glassEffect()  // Standard: reguläre Variante, Kapselform

Anpassen von Form und Farbton

Text("Hallo, Welt!")
    .font(.title)
    .padding()
    .glassEffect(.regular.tint(.orange).interactive(), in: .rect(cornerRadius: 16.0))

Wichtige Anpassungsoptionen:

  • .regular – Standard-Glaseffekt
  • .tint(Color) – Farbton für Hervorhebung hinzufügen
  • .interactive() – Reaktion auf Berührungs- und Zeigerinteraktionen
  • Form: .capsule (Standard), .rect(cornerRadius:), .circle

Glas-Button-Stile

Button("Klick mich") { /* Aktion */ }
    .buttonStyle(.glass)

Button("Wichtig") { /* Aktion */ }
    .buttonStyle(.glassProminent)

GlassEffectContainer für mehrere Elemente

Mehrere Glasansichten immer in einem Container für Leistung und Morphen zusammenfassen:

GlassEffectContainer(spacing: 40.0) {
    HStack(spacing: 40.0) {
        Image(systemName: "scribble.variable")
            .frame(width: 80.0, height: 80.0)
            .font(.system(size: 36))
            .glassEffect()

        Image(systemName: "eraser.fill")
            .frame(width: 80.0, height: 80.0)
            .font(.system(size: 36))
            .glassEffect()
    }
}

Der Parameter spacing steuert den Verschmelzungsabstand – nähere Elemente verschmelzen ihre Glasformen miteinander.

Vereinigen von Glaseffekten

Mehrere Ansichten mit glassEffectUnion zu einer einzigen Glasform kombinieren:

@Namespace private var namespace

GlassEffectContainer(spacing: 20.0) {
    HStack(spacing: 20.0) {
        ForEach(symbolSet.indices, id: \.self) { item in
            Image(systemName: symbolSet[item])
                .frame(width: 80.0, height: 80.0)
                .glassEffect()
                .glassEffectUnion(id: item < 2 ? "group1" : "group2", namespace: namespace)
        }
    }
}

Morphing-Übergänge

Erstellen Sie sanftes Morphen, wenn Glaselemente erscheinen/verschwinden:

@State private var isExpanded = false
@Namespace private var namespace

GlassEffectContainer(spacing: 40.0) {
    HStack(spacing: 40.0) {
        Image(systemName: "scribble.variable")
            .frame(width: 80.0, height: 80.0)
            .glassEffect()
            .glassEffectID("pencil", in: namespace)

        if isExpanded {
            Image(systemName: "eraser.fill")
                .frame(width: 80.0, height: 80.0)
                .glassEffect()
                .glassEffectID("eraser", in: namespace)
        }
    }
}

Button("Umschalten") {
    withAnimation { isExpanded.toggle() }
}
.buttonStyle(.glass)

Horizontales Scrollen unter die Seitenleiste verlängern

Damit horizontaler Scroll-Inhalt unter eine Seitenleiste oder einen Inspektor reicht, stellen Sie sicher, dass der ScrollView-Inhalt die linken/rechten Kanten des Containers erreicht. Das System behandelt das Scrollverhalten unter der Seitenleiste automatisch, wenn das Layout bis zu den Kanten reicht – es ist kein zusätzlicher Modifikator erforderlich.

Kernmuster – UIKit

Grundlegendes UIGlassEffect

let glassEffect = UIGlassEffect()
glassEffect.tintColor = UIColor.systemBlue.withAlphaComponent(0.3)
glassEffect.isInteractive = true

let visualEffectView = UIVisualEffectView(effect: glassEffect)
visualEffectView.translatesAutoresizingMaskIntoConstraints = false
visualEffectView.layer.cornerRadius = 20
visualEffectView.clipsToBounds = true

view.addSubview(visualEffectView)
NSLayoutConstraint.activate([
    visualEffectView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    visualEffectView.centerYAnchor.constraint(equalTo: view.centerYAnchor),
    visualEffectView.widthAnchor.constraint(equalToConstant: 200),
    visualEffectView.heightAnchor.constraint(equalToConstant: 120)
])

// Inhalt zu contentView hinzufügen
let label = UILabel()
label.text = "Liquid Glass"
label.translatesAutoresizingMaskIntoConstraints = false
visualEffectView.contentView.addSubview(label)
NSLayoutConstraint.activate([
    label.centerXAnchor.constraint(equalTo: visualEffectView.contentView.centerXAnchor),
    label.centerYAnchor.constraint(equalTo: visualEffectView.contentView.centerYAnchor)
])

UIGlassContainerEffect für mehrere Elemente

let containerEffect = UIGlassContainerEffect()
containerEffect.spacing = 40.0

let containerView = UIVisualEffectView(effect: containerEffect)

let firstGlass = UIVisualEffectView(effect: UIGlassEffect())
let secondGlass = UIVisualEffectView(effect: UIGlassEffect())

containerView.contentView.addSubview(firstGlass)
containerView.contentView.addSubview(secondGlass)

Scrolleffekte an den Kanten

scrollView.topEdgeEffect.style = .automatic
scrollView.bottomEdgeEffect.style = .hard
scrollView.leftEdgeEffect.isHidden = true

Toolbar-Glasintegration

let favoriteButton = UIBarButtonItem(image: UIImage(systemName: "heart"), style: .plain, target: self, action: #selector(favoriteAction))
favoriteButton.hidesSharedBackground = true  // Vom gemeinsamen Glashintergrund abmelden

Kernmuster – WidgetKit

Erkennung des Darstellungsmodus

struct MyWidgetView: View {
    @Environment(\.widgetRenderingMode) var renderingMode

    var body: some View {
        if renderingMode == .accented {
            // Eingefärbter Modus: weiß eingefärbter, thematischer Glashintergrund
        } else {
            // Vollfarbmodus: Standarddarstellung
        }
    }
}

Akzentgruppen für visuelle Hierarchie

HStack {
    VStack(alignment: .leading) {
        Text("Titel")
            .widgetAccentable()  // Akzentgruppe
        Text("Untertitel")
            // Primäre Gruppe (Standard)
    }
    Image(systemName: "star.fill")
        .widgetAccentable()  // Akzentgruppe
}

Bilddarstellung im akzentuierten Modus

Image("myImage")
    .widgetAccentedRenderingMode(.monochrome)

Container-Hintergrund

VStack { /* Inhalt */ }
    .containerBackground(for: .widget) {
        Color.blue.opacity(0.2)
    }

Wichtige Designentscheidungen

EntscheidungBegründung
GlassEffectContainer-UmhüllungLeistungsoptimierung, ermöglicht Morphen zwischen Glaselementen
Parameter spacingSteuert den Verschmelzungsabstand – Feinabstimmung, wie nah Elemente sein müssen, um zu verschmelzen
@Namespace + glassEffectIDErmöglicht sanfte Morphing-Übergänge bei Änderungen der Ansichtshierarchie
Modifikator interactive()Explizite Zustimmung für Berührungs-/Zeigerreaktionen – nicht jedes Glas sollte reagieren
UIGlassContainerEffect in UIKitGleiches Containermuster wie in SwiftUI für Konsistenz
Akzentuierter Darstellungsmodus in WidgetsDas System wendet eingefärbtes Glas an, wenn der Benutzer einen eingefärbten Startbildschirm auswählt

Best Practices

  • GlassEffectContainer immer verwenden, wenn Glas auf mehrere Geschwisteransichten angewendet wird – es ermöglicht Morphen und verbessert die Rendering-Leistung
  • .glassEffect() nach anderen Darstellungsmodifikatoren (frame, font, padding) anwenden
  • .interactive() nur für Elemente verwenden, die auf Benutzerinteraktionen reagieren (Buttons, umschaltbare Elemente)
  • Abstand in Containern sorgfältig wählen, um zu steuern, wann Glaseffekte verschmelzen
  • withAnimation verwenden, wenn Ansichtshierarchien geändert werden, um sanfte Morphing-Übergänge zu ermöglichen
  • Über Darstellungsmodi hinweg testen – Hell-, Dunkel- und akzentuierte/eingefärbte Modi
  • Barrierefreiheitskontrast sicherstellen – Text auf Glas muss lesbar bleiben

Zu vermeidende Anti-Patterns

  • Mehrere eigenständige .glassEffect()-Ansichten ohne GlassEffectContainer verwenden
  • Zu viele Glaseffekte verschachteln – verschlechtert Leistung und visuelle Klarheit
  • Glas auf jede Ansicht anwenden – für interaktive Elemente, Symbolleisten und Karten reservieren
  • clipsToBounds = true in UIKit bei Verwendung von Eckenradien vergessen
  • Akzentuierten Darstellungsmodus in Widgets ignorieren – unterbricht die eingefärbte Startbildschirm-Darstellung
  • Undurchsichtige Hintergründe hinter Glas verwenden – hebt den Transluzenzeffekt auf

Wann verwenden

  • Navigationsleisten, Symbolleisten und Tab-Leisten mit dem neuen iOS 26-Design
  • Schwebende Aktionsbuttons und kartenartige Container
  • Interaktive Steuerelemente, die visuelle Tiefe und Berührungsfeedback benötigen
  • Widgets, die in das Liquid-Glass-Erscheinungsbild des Systems integriert werden sollen
  • Morphing-Übergänge zwischen zusammenhängenden UI-Zuständen

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/claude-api

Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

affaan-m/everything-claude-code

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/everything-claude-code-conventions

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

affaan-m/gget

gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.

affaan-m/literature-review

Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.

affaan-m/motion-ui

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

affaan-m/project-guidelines-example

Example project-specific skill template based on a real production application.

affaan-m/pubmed-database

Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring.

affaan-m/scholar-evaluation

Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.

affaan-m/uspto-database

USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

Verwandte Skills