Communitygithub.com

ComeOnOliver/skillshub – SwiftUI 26 Features

Verwenden Sie dieses Skill bei der Implementierung von iOS 26 SwiftUI-Funktionen. Es deckt das Liquid Glass Designsystem, Leistungsverbesserungen, das @Animatable-Makro, 3D-räumliches Layout, Szenenüberbrückung, WebView/WebPage, AttributedString-Textbearbeitung, Drag & Drop-Erweiterungen und visionOS-Integration ab.

Was ist skillshub – SwiftUI 26 Features?

Dieses Skill bietet eine umfassende Anleitung zu den neuen SwiftUI-Funktionen in iOS 26, iPadOS 26, macOS Tahoe, watchOS 26 und visionOS 26. Es behandelt das Liquid Glass Designsystem, das automatisch von Navigation-Containern, Tab-Leisten, Toolbars und Schaltflächen übernommen wird, sowie neue Toolbar-APIs wie `ToolbarSpacer`, benutzerdefinierbare Toolbars und morphing-Effekte. Darüber hinaus werden Slider-Verbesserungen (benutzerdefinierte Teilstriche, eingeschränkte Auswahlbereiche), neue View-Modifier wie `safeAreaBar` und `lineHeight`, iPad-Menüleisten und macOS-Fenstervergrößerungen beschrieben. Das Skill ist besonders nützlich für Entwickler, die die neuesten SwiftUI-Funktionen plattformübergreifend nutzen möchten. Es basiert auf den WWDC-2025-Ankündigungen und der SKILL.md-Dokumentation, die detaillierte Codebeispiele und Hinweise zur Leistungsoptimierung enthält.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-swiftui-26-ref

In Ihrer bevorzugten KI fragen

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

Dokumentation

SwiftUI 26 Funktionen

Übersicht

Umfassender Leitfaden zu den neuen SwiftUI-Funktionen in iOS 26, iPadOS 26, macOS Tahoe, watchOS 26 und visionOS 26. Vom Liquid Glass Designsystem bis zur Textbearbeitung machen diese Verbesserungen SwiftUI auf allen Apple-Plattformen leistungsfähiger.

Kernprinzip: Von Verbesserungen auf niedriger Ebene bis hin zu den Schaltflächen in Ihrer Benutzeroberfläche gibt es einige große Verbesserungen im gesamten System.

Wann dieses Skill verwendet werden sollte

  • Übernahme des Liquid Glass Designsystems
  • Implementierung von Rich-Text-Bearbeitung mit AttributedString
  • Einbetten von Webinhalten mit WebView
  • Optimierung der Listen- und Scroll-Leistung
  • Verwenden des @Animatable-Makros für benutzerdefinierte Animationen
  • Erstellen von 3D-räumlichen Layouts auf visionOS
  • Überbrückung von SwiftUI-Szenen zu UIKit/AppKit-Apps
  • Implementieren von Drag & Drop mit mehreren Elementen
  • Erstellen von 3D-Diagrammen mit Chart3D
  • Hinzufügen von Widgets zu visionOS oder CarPlay
  • Hinzufügen benutzerdefinierter Teilstriche zu Schiebereglern (Kapitelmarkierungen, Wertindikatoren)
  • Einschränken von Schieberegler-Auswahlbereichen mit enabledBounds
  • Anpassen des Schieberegler-Erscheinungsbilds (Daumen-Sichtbarkeit, aktuelle Wertbeschriftungen)
  • Erstellen von klebrigen Safe-Area-Leisten mit Unschärfeeffekten
  • Öffnen von URLs im In-App-Browser
  • Verwenden systemgestalteter Schließen- und Bestätigungsschaltflächen
  • Anwenden von Glas-Schaltflächenstilen (iOS 26.1+)
  • Steuern des Schaltflächen-Größenverhaltens
  • Implementieren kompakter Suchtoolbars
  • Einstellen der Zeilenhöhe oder des Basislinienabstands für Text

Systemanforderungen

iOS 26+, iPadOS 26+, macOS Tahoe+, watchOS 26+, visionOS 26+


Liquid Glass Designsystem

Für eine umfassende Abdeckung siehe axiom-liquid-glass (Designprinzipien, Varianten, Überprüfungsdruck) und axiom-liquid-glass-ref (appweite Übernahmeanleitung). Dieser Abschnitt behandelt nur WWDC-256-spezifische APIs.

Automatische Übernahme

Neu kompilieren mit dem iOS 26 SDK – Navigationscontainer, Tab-Leisten, Toolbars, Kippschalter, segmentierte Picker und Schieberegler übernehmen automatisch das neue Design. Bordered-Buttons haben standardmäßig eine Kapselform. Blätter erhalten einen Liquid Glass-Hintergrund (entfernen Sie alle presentationBackground-Anpassungen).

Toolbar-APIs (iOS 26)

ToolbarSpacer

.toolbar {
    ToolbarItem(placement: .bottomBar) { Button("Archivieren", systemImage: "archivebox") { } }
    ToolbarSpacer(.flexible, placement: .bottomBar)  // Elemente auseinanderschieben
    ToolbarItem(placement: .bottomBar) { Button("Verfassen", systemImage: "square.and.pencil") { } }
}
// .fixed trennt Gruppen visuell; .flexible schiebt auseinander (wie Spacer im HStack)

ToolbarItemGroup (Visuelle Gruppierung)

Elemente in einer ToolbarItemGroup teilen sich einen einzigen Glashintergrund-"Pill". ToolbarItemPlacement steuert das visuelle Erscheinungsbild: confirmationAction → glassProminent-Stil, cancellationAction → Standard-Glas. Verwenden Sie .sharedBackgroundVisibility(.hidden), um Elemente (z.B. Avatare) vom Gruppenhintergrund auszuschließen.

Toolbar-Morphing

Hängen Sie .toolbar {} an einzelne Ansichten innerhalb von NavigationStack an (nicht an NavigationStack selbst). iOS 26 morphiert zwischen ansichtenspezifischen Toolbars während Push/Pop. Verwenden Sie toolbar(id:) mit passenden ToolbarItem(id:) über Bildschirme hinweg für Elemente, die stabil bleiben sollen (kein Hüpfen):

// MailboxList
.toolbar(id: "main") {
    ToolbarItem(id: "filter", placement: .bottomBar) { Button("Filter") { } }
    ToolbarSpacer(.flexible, placement: .bottomBar)
    ToolbarItem(id: "compose", placement: .bottomBar) { Button("Neue Nachricht") { } }
}
// MessageList – "filter" fehlt (animiert heraus), "compose" bleibt stabil
.toolbar(id: "main") {
    ToolbarSpacer(.flexible, placement: .bottomBar)
    ToolbarItem(id: "compose", placement: .bottomBar) { Button("Neue Nachricht") { } }
}

Häufigster Fehler: Toolbar auf NavigationStack = nichts zum Morphen.

DefaultToolbarItem

Positionieren Sie systembereitgestellte Elemente (wie Suche) in Ihrem Toolbar-Layout neu:

DefaultToolbarItem(kind: .search, placement: .bottomBar)
// Ersetzt die Standardplatzierung des Systems für den entsprechenden Typ

Verwenden Sie dies in einer reduzierten NavigationSplitView-Seitenleiste, um anzugeben, welche Spalte die Suche auf dem iPhone zeigt. Wickeln Sie es für Rückwärtskompatibilität in if #available(iOS 26.0, *) ein.

Benutzerdefinierbare Toolbars

toolbar(id:) ermöglicht die Benutzeranpassung (neu anordnen, ein-/ausblenden). Nur .secondaryAction-Elemente unterstützen die Anpassung auf iPadOS. Verwenden Sie showsByDefault: false für optionale Elemente. Fügen Sie ToolbarCommands() für das macOS-Menüelement hinzu.

Andere Toolbar-Funktionen

  • .navigationSubtitle("3 ungelesen") – Sekundäre Zeile unter dem Titel
  • .badge(3) auf Toolbar-Elementen – Benachrichtigungsanzahlen
  • Monochrome Symbolwiedergabe – Reduziert visuelles Rauschen; Tönung für Bedeutung, nicht für Dekoration
  • Rollkantenunschärfe – Automatisch, kein Code erforderlich

Unten ausgerichtete Suche

Grundlegende Such-APIs: Siehe axiom-swiftui-search-ref. Dieser Abschnitt behandelt nur iOS 26-Verfeinerungen.

NavigationSplitView {
    List { }.searchable(text: $searchText)
}
// Unten ausgerichtet auf dem iPhone, oben rechts auf dem iPad (automatisch)
// Verwenden Sie placement: .sidebar, um die in die Seitenleiste eingebettete Suche auf dem iPad wiederherzustellen
  • searchToolbarBehavior(.minimize) – Kompakte Suche, die sich bei Antippen erweitert
  • Tab(role: .search) – Dedizierter Such-Tab; Suchfeld ersetzt die Tab-Leiste. Siehe swiftui-nav-ref Abschnitt 5.7

Glaseffekt für benutzerdefinierte Ansichten

Button("Nach oben", systemImage: "chevron.up") { scrollToTop() }
    .padding()
    .glassEffect()  // Fügen Sie .interactive für benutzerdefinierte Steuerelemente auf iOS hinzu
  • GlassEffectContainer – Erforderlich, wenn mehrere Glaselemente nahe beieinander sind (Glas kann kein Glas abtasten)
  • glassEffectID(_:in:) – Fließende Morphing-Übergänge zwischen Glaselementen mit einem Namespace
  • Sheet-Morphing – Verwenden Sie .matchedTransitionSource + .navigationTransition(.zoom(...)), um Sheets von Schaltflächen aus zu morphen

Änderungen bei Schaltflächen und Steuerelementen

  • Standardmäßig Kapselform für bordered-Buttons (Überschreiben mit .buttonBorderShape(.roundedRectangle))
  • .controlSize(.extraLarge) – Neue extra große Schaltflächengröße
  • .controlSize(.small) auf Containern – Behalten Sie die Dichte vor iOS 26 bei
  • GlassButtonStyle(.clear/.glass/.tint) – Glas-Schaltflächenvarianten (iOS 26.1+)
  • .buttonSizing(.fit/.stretch/.flexible) – Steuern des Schaltflächen-Layoutverhaltens
  • Button(role: .close) / Button(role: .confirm) – Systemgestaltete Schließen/Bestätigen
  • .clipShape(.rect(cornerRadius: 12, style: .containerConcentric)) – Eckenkonzentrizität
  • Menüs: Symbole auf der vorderen Kante, konsistent für iOS/macOS

Schieberegler-Verbesserungen

iOS 26 fügt benutzerdefinierte Teilstriche, eingeschränkte Auswahlbereiche, aktuelle Wertbeschriftungen und Daumen-Sichtbarkeitssteuerung hinzu.

Schieberegler-Teilstriche

Kerntypen: SliderTick<V>, SliderTickContentForEach, SliderTickBuilder

// Statische Teilstriche mit Beschriftungen
Slider(value: $value, in: 0...10) {
    Text("Bewertung")
} ticks: {
    SliderTick(0) { Text("Min") }
    SliderTick(5) { Text("Mitte") }
    SliderTick(10) { Text("Max") }
}

// Dynamische Teilstriche aus einer Sammlung
SliderTickContentForEach(stops, id: \.self) { value in
    SliderTick(value) { Text("\(Int(value))°").font(.caption2) }
}

// Schrittbasierte Teilstriche (wird für jeden Schritt aufgerufen)
Slider(value: $volume, in: 0...10, step: 2, label: { Text("Lautstärke") }, tick: { value in
    SliderTick(value) { Text("\(Int(value))") }
})

API-Einschränkung: SliderTickContentForEach erfordert, dass Data.Element mit dem Werttyp von SliderTick<V> übereinstimmt. Extrahieren Sie für benutzerdefinierte Strukturen numerische Werte: chapters.map(\.time) und suchen Sie dann Beschriftungen über chapters.first(where: { $0.time == time }).

Voll ausgestatteter Schieberegler

Slider(
    value: $rating, in: 0...100,
    neutralValue: 50,           // Startpunkt / Mittelwert
    enabledBounds: 20...80,     // Auswählbaren Bereich einschränken
    label: { Text("Bewertung") },
    currentValueLabel: { Text("\(Int(rating))") },
    minimumValueLabel: { Text("0") },
    maximumValueLabel: { Text("100") },
    ticks: { SliderTick(50) { Text("Mitte") } },
    onEditingChanged: { editing in print(editing ? "Gestartet" : "Beendet") }
)

sliderThumbVisibility

.sliderThumbVisibility(.hidden) – Daumen für Medienfortschrittsanzeigen und minimales UI ausblenden. Optionen: .automatic, .visible, .hidden. Auf watchOS immer sichtbar.


Neue View-Modifier

safeAreaBar

Klebrige Leisten mit integrierter progressiver Unschärfe:

List { ForEach(1...20, id: \.self) { Text("\($0). Element") } }
    .safeAreaBar(edge: .bottom) {
        Text("Aktionsleiste unten").padding(.vertical, 15)
    }
    .scrollEdgeEffectStyle(.soft, for: .bottom) // oder .hard

Funktioniert wie safeAreaInset, aber mit Unschärfe. Die Leiste bleibt fixiert, während der Inhalt darunter scrollt.

onOpenURL Verbesserung

@Environment(\.openURL) var openURL
// openURL(url, prefersInApp: true) – Öffnet im SFSafariViewController-ähnlichen In-App-Browser
// Standardmäßig öffnet Link in Safari; prefersInApp hält Benutzer in Ihrer App

searchToolbarBehavior

Siehe axiom-swiftui-search-ref für die grundlegenden .searchable-APIs. iOS 26 fügt hinzu:

.searchable(text: $searchText)
.searchToolbarBehavior(.minimize)  // Kompakter Button, erweitert sich bei Antippen

Auch: .searchPresentationToolbarBehavior(.avoidHidingContent) (iOS 17.1+) hält den Titel während der Suche sichtbar.

Rückwärtskompatibler Wrapper für Apps, die auf iOS 18+26 abzielen:

extension View {
    @ViewBuilder func minimizedSearch() -> some View {
        if #available(iOS 26.0, *) {
            self.searchToolbarBehavior(.minimize)
        } else { self }
    }
}

// Verwendung
.searchable(text: $searchText)
.minimizedSearch()

Verfügbarkeitsmuster für Toolbar-Elemente:

.toolbar {
    if #available(iOS 26.0, *) {
        DefaultToolbarItem(kind: .search, placement: .bottomBar)
        ToolbarSpacer(.flexible, placement: .bottomBar)
    }
    ToolbarItem(placement: .bottomBar) {
        NewNoteButton()
    }
}
.searchable(text: $searchText)

Button-Rollen, GlassButtonStyle, buttonSizing – Siehe Abschnitt Liquid Glass Designsystem oben.

lineHeight (iOS 26)

Legt den Basislinien-zu-Basislinien-Abstand zwischen Textzeilen fest. Intuitiver als .lineSpacing(), das den Abstand vom unteren Rand einer Zeile zum oberen Rand der nächsten Zeile misst.

Voreinstellungen

Text("Lorem ipsum...")
    .lineHeight(.loose)     // Erhöhter Abstand für offene Layouts
    .lineHeight(.tight)     // Reduzierter Abstand für kompakte Layouts
    .lineHeight(.normal)    // Konstante Höhe basierend auf dem Vielfachen der Punktgröße
    .lineHeight(.variable)  // Verwendet Schriftmetriken zur Höhenberechnung

Präzise Steuerung

// Proportional zur Schriftgröße skalieren
Text("Skaliert mit Textgröße")
    .lineHeight(.multiple(factor: 2))

// Relativ zur Punktgröße mit festem Zuwachs
Text("Punktgrößenrelativ")
    .lineHeight(.leading(increase: 30))

// Absoluter fester Wert – skaliert NICHT mit Dynamic Type
Text("Feste Höhe")
    .lineHeight(.exact(points: 30))

AttributedString-Unterstützung

var s = AttributedString("Absatz\nmit mehreren\nZeilen.")
s.lineHeight = .exact(points: 32)
s.lineHeight = .multiple(factor: 2.5)
s.lineHeight = .loose

Vergleich mit bestehenden APIs

APIMisstVerfügbar
.lineHeight()Basislinie zu BasislinieiOS 26+
.lineSpacing()Unterkante Zeile zu Oberkante nächsteriOS 13+
.font(.body.leading(.tight))Schriftart-Voreinstellung für ZeilenabstandiOS 14+

Querverweis axiom-typography-ref – Vollständiges Typografiesystem einschließlich Dynamic Type, Tracking und Internationalisierung


iPad-Verbesserungen

Menüleiste

Zugriff auf allgemeine Aktionen über das Wischmenü

.commands {
    TextEditingCommands() // Gleiche API wie macOS-Menüleiste

    CommandGroup(after: .newItem) {
        Button("Notiz hinzufügen") {
            addNote()
        }
        .keyboardShortcut("n", modifiers: [.command, .shift])
    }
}
// Erstellt eine Menüleiste auf dem iPad, wenn Benutzer nach unten wischen

Größenveränderbare Fenster

Fließende Größenänderung auf dem iPad

// MIGRATION ERFORDERLICH:
// Entfernen Sie den veralteten Property-List-Schlüssel in iPadOS 26:
// UIRequiresFullscreen (gesamter Schlüssel veraltet, alle Werte)

// Für Split-View-Navigation zeigt das System automatisch Spalten an/aus
// basierend auf dem verfügbaren Platz während der Größenänderung
NavigationSplitView {
    Sidebar()
} detail: {
    Detail()
}
// Passt sich automatisch an die Größenänderung an

Referenz "Elevate the design of your iPad app" (WWDC 2025)


macOS-Fensterverbesserungen

Synchronisierte Fenstergrößen-Änderungsanimationen

.windowResizeAnchor(.topLeading) // Passt den Animationsursprung an

// SwiftUI synchronisiert jetzt Animationen zwischen Inhaltsansichtsgrößenänderungen
// und Fenstergrößenänderungen – großartig für die Kontinuität beim Wechseln von Tabs

Leistungsverbesserungen

List-Leistung (macOS-Fokus)

Massive Verbesserungen für große Listen

  • 6x schnelleres Laden für Listen mit 100.000+ Elementen auf macOS
  • 16x schnellere Aktualisierungen für große Listen
  • Noch größere Verbesserungen für noch größere Listen
  • Verbesserungen kommen allen Plattformen zugute (iOS, iPadOS, watchOS)
List(trips) { trip in // 100k+ Elemente
    TripRow(trip: trip)
}
// Lädt 6x schneller, aktualisiert 16x schneller auf macOS (iOS 26+)

Scroll-Leistung

Reduzierte verworfene Frames

SwiftUI hat die Planung von UI-Updates auf iOS und macOS verbessert. Dies verbessert die Reaktionsfähigkeit und ermöglicht es SwiftUI, noch mehr Arbeit für die Vorbereitung bevorstehender Frames zu leisten. Insgesamt reduziert es die Wahrscheinlichkeit, dass Ihre App beim schnellen Scrollen bei hohen Bildraten Frames verwirft.

Verschachtelte ScrollViews mit Lazy-Stacks

Diashows und Multi-Achsen-Scrolling

ScrollView(.horizontal) {
    LazyHStack {
        ForEach(photoSets) { photoSet in
            ScrollView(.vertical) {
                LazyVStack {
                    ForEach(photoSet.photos) { photo in
                        PhotoView(photo: photo)
                    }
                }
            }
        }
    }
}
// Verschachtelte ScrollViews verzögern jetzt das Laden mit Lazy-Stacks korrekt
// Großartig zum Erstellen von Diashows

SwiftUI-Leistungsinstrument

Neues Profiling-Tool in Xcode

Verfügbare Spuren:

  • Lange Ansichts-Body-Updates – Identifizieren teurer Body-Berechnungen
  • Plattformansichts-Updates – Verfolgung von Änderungen auf der Plattformebene
  • Grafikkomponente – Verfolgung von Rendering-Engpässen

@Animatable Makro

Deklarative Animationen für Strukturen

@Animatable
struct OrbitProgress {
    var progress: Double
    var tilt: Double = 0
}

struct ContentView: View {
    @State private var progress: Double = 0.5

    var body: some View {
        OrbitView(progress: $progress)
    }
}
  • Erstellt automatisch animatableData für jede animierbare Eigenschaft
  • Funktioniert mit withAnimation und impliziten Animationen
  • Unterstützt Vektortypen wie CGPoint, SIMD3, benutzerdefinierte Strukturen

3D Spatial Layout

visionOS und andere Plattformen

struct SpatialView: View {
    var body: some View {
        ZStack {
            Model3D(named: "scene") { phase in
                switch phase {
                case .empty:
                    ProgressView()
                case .success(let model):
                    model.resizable()
                        .scaleEffect(0.5)
                        .rotation3DEffect(.degrees(45), axis: (x: 0, y: 1, z: 0))
                case .failure(let error):
                    Text("Fehler beim Laden: \(error.localizedDescription)")
                @unknown default:
                    EmptyView()
                }
            }
            .frame(depth: 200) // Neue depth-Dimension
        }
    }
}

Neue 3D-Modifier

  • .frame(depth:) – Legt die Tiefe in der 3D-Umgebung fest
  • .rotation3DEffect(_:axis:) – Rotation im 3D-Raum
  • .perspectiveRotationEffect(_:axis:) – Perspektivische Rotationen
  • .scaleEffect(_:depth:) – Skalierung inkl. Tiefe

Szenenüberbrückung (Scene Bridging)

SwiftUI-Szenen zu UIKit/AppKit

// UIKit-Integration
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        let contentView = ContentView()
        if let windowScene = scene as? UIWindowScene {
            let window = UIWindow(windowScene: windowScene)
            window.rootViewController = UIHostingController(rootView: contentView)
            self.window = window
            window.makeKeyAndVisible()
        }
    }
}

SwiftUI-Szenen in bestehenden Projekten verwenden

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
// Vollständige SwiftUI-App-Struktur

WebView/WebPage

Einbetten von Webinhalten

import SwiftUI

struct WebViewPage: View {
    var body: some View {
        WebView(url: URL(string: "https://example.com")!)
            .frame(height: 400)
    }
}

// Mit benutzerdefinierten Einstellungen
struct ConfigurableWebView: View {
    var body: some View {
        WebView(url: URL(string: "https://example.com")!,
                configuration: { config in
            config.allowsInlineMediaPlayback = true
            config.mediaTypesRequiringUserActionForPlayback = []
        })
    }
}

AttributedString Rich Text Bearbeitung

Neue Textbearbeitungsfunktionen

struct RichTextEditor: View {
    @State private var text: AttributedString = {
        var s = AttributedString("Dies ist ein **fetter** Text.")
        s.font = .body
        s.foregroundColor = .primary
        if let range = s.range(of: "fetter") {
            s[range].font = .body.bold()
            s[range].foregroundColor = .blue
        }
        return s
    }()

    var body: some View {
        TextEditor(text: $text)
            .font(.body)
            .padding()
    }
}

Unterstützte Attribute

  • .font – Schriftart und -größe
  • .foregroundColor – Textfarbe
  • .backgroundColor – Hintergrundfarbe
  • .link – Hyperlinks
  • .underlineStyle – Unterstreichungsstil
  • .strikethroughStyle – Durchstreichungsstil
  • .kern – Zeichenabstand
  • .tracking – Tracking (Schriftlaufweite)
  • .baselineOffset – Basislinienversatz
  • .lineHeight – Zeilenhöhe

Drag & Drop Erweiterungen

Mehrere Elemente ziehen

struct DraggableList: View {
    var items: [String]

    var body: some View {
        List(items, id: \.self) { item in
            Text(item)
                .draggable(item) {
                    // Vorschau während des Ziehens
                    Text(item)
                        .padding()
                        .background(Color.blue)
                        .clipShape(RoundedRectangle(cornerRadius: 8))
                }
        }
    }
}

Ablegen mehrerer Elemente

struct DropTarget: View {
    @State private var droppedItems: [String] = []

    var body: some View {
        VStack {
            Text("Abgelegte Elemente: \(droppedItems.count)")
            List(droppedItems, id: \.self) { item in
                Text(item)
            }
        }
        .dropDestination(for: String.self) { items, location in
            droppedItems.append(contentsOf: items)
            return true
        }
    }
}

Verbesserungen

  • Verbesserte Vorschau während des Ziehens
  • Bessere Unterstützung für benutzerdefinierte Datentypen
  • Nahtlose Integration mit NSItemProvider

visionOS Integration

Neue visionOS-spezifische APIs

struct VisionOSView: View {
    @Environment(\.openWindow) private var openWindow
    @Environment(\.dismissWindow) private var dismissWindow

    var body: some View {
        VStack(spacing: 20) {
            Text("Willkommen in visionOS")
                .font(.extraLargeTitle)

            HStack(spacing: 30) {
                Button("Fenster öffnen") {
                    openWindow(id: "detail")
                }
                .glassBackgroundEffect()

                Button("Fenster schließen") {
                    dismissWindow(id: "detail")
                }
                .glassBackgroundEffect()
            }
        }
        .padding(40)
        .ornament(attachmentAnchor: .scene(.topTrailing)) {
            Button("Einstellungen", systemImage: "gear") {
                // Einstellungen öffnen
            }
            .labelStyle(.iconOnly)
        }
    }
}

Neue visionOS-Typen

  • .glassBackgroundEffect() – Glas-Hintergrund für visionOS
  • .ornament(attachmentAnchor:content:) – Verzierungen für Fenster
  • .placement für Fensterpositionierung
  • .defaultWindowPlacement – Standard-Fensterplatzierung

3D Chart3D

Erstellen von 3D-Diagrammen

struct Chart3DView: View {
    var body: some View {
        Chart3D {
            Bar3D(x: "A", y: 10, z: 5)
            Bar3D(x: "B", y: 20, z: 8)
            Bar3D(x: "C", y: 15, z: 12)
        }
        .chart3DViewRotation(angles: (x: 30, y: 45, z: 0))
    }
}

Anpassungsmöglichkeiten

  • Farbgebung
  • Achsenbeschriftungen
  • Rotation und Perspektive
  • Interaktive Elemente

Widgets auf visionOS und CarPlay

visionOS-Widgets

struct VisionOSWidget: Widget {
    let kind: String = "VisionOSWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            WidgetEntryView(entry: entry)
        }
        .configurationDisplayName("Mein Widget")
        .description("Ein Widget für visionOS.")
        .supportedFamilies([.systemSmall, .systemMedium])
    }
}

CarPlay-Widgets

struct CarPlayWidget: Widget {
    let kind: String = "CarPlayWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            WidgetEntryView(entry: entry)
        }
        .configurationDisplayName("CarPlay-Widget")
        .description("Ein Widget für CarPlay.")
        .supportedFamilies([.systemSmall])
    }
}

Zusammenfassung

Dieser Leitfaden deckt die wichtigsten neuen Funktionen von SwiftUI in iOS 26 ab. Weitere Informationen finden Sie in der WWDC-2025-Dokumentation und den entsprechenden axiom-Referenzen.

Wichtige Ressourcen:

  • axiom-liquid-glass – Designprinzipien und Varianten
  • axiom-liquid-glass-ref – Appweite Übernahmeanleitung
  • axiom-swiftui-search-ref – Such-APIs
  • axiom-typography-ref – Typografiesystem
  • swiftui-nav-ref – Navigationsreferenz

Individual skills in this repo

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

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Verwandte Skills